Skip to content

A native macOS / windows / Linux database IDE built with Swift and AppKit. Connect to PostgreSQL, MySQL, SQLite, and Redis from a single app with a fast, keyboard-driven interface.

C++
6.5 KB
Raw Blame
#pragma once

#include <chrono>
#include <optional>
#include <string>
#include <string_view>
#include <vector>

#include "Core/Enums/DatabaseType.h"
#include "Core/Enums/SQLDialect.h"

namespace gridex {

enum class TableKind {
    Table,
    View,
    MaterializedView,
    ForeignTable,
};

inline std::string_view rawValue(TableKind k) {
    switch (k) {
        case TableKind::Table:            return "table";
        case TableKind::View:             return "view";
        case TableKind::MaterializedView: return "materializedView";
        case TableKind::ForeignTable:     return "foreignTable";
    }
    return "";
}

enum class ForeignKeyAction {
    Cascade,
    SetNull,
    SetDefault,
    Restrict,
    NoAction,
};

inline std::string_view rawValue(ForeignKeyAction a) {
    switch (a) {
        case ForeignKeyAction::Cascade:    return "CASCADE";
        case ForeignKeyAction::SetNull:    return "SET NULL";
        case ForeignKeyAction::SetDefault: return "SET DEFAULT";
        case ForeignKeyAction::Restrict:   return "RESTRICT";
        case ForeignKeyAction::NoAction:   return "NO ACTION";
    }
    return "";
}

enum class ConstraintType {
    PrimaryKey,
    Unique,
    Check,
    Exclusion,
};

inline std::string_view rawValue(ConstraintType t) {
    switch (t) {
        case ConstraintType::PrimaryKey: return "PRIMARY KEY";
        case ConstraintType::Unique:     return "UNIQUE";
        case ConstraintType::Check:      return "CHECK";
        case ConstraintType::Exclusion:  return "EXCLUSION";
    }
    return "";
}

struct ColumnInfo {
    std::string name;
    std::string dataType;
    bool isNullable = true;
    std::optional<std::string> defaultValue;
    bool isPrimaryKey = false;
    bool isAutoIncrement = false;
    std::optional<std::string> comment;
    int ordinalPosition = 0;
    std::optional<int> characterMaxLength;
    std::optional<std::string> checkConstraint;

    bool operator==(const ColumnInfo&) const noexcept = default;
};

struct IndexInfo {
    std::string name;
    std::vector<std::string> columns;
    bool isUnique = false;
    std::optional<std::string> type;
    std::optional<std::string> tableName;
    std::optional<std::string> condition;
    std::optional<std::string> include;
    std::optional<std::string> comment;

    bool operator==(const IndexInfo&) const noexcept = default;
};

struct ForeignKeyInfo {
    std::optional<std::string> name;
    std::vector<std::string> columns;
    std::string referencedTable;
    std::vector<std::string> referencedColumns;
    ForeignKeyAction onDelete = ForeignKeyAction::NoAction;
    ForeignKeyAction onUpdate = ForeignKeyAction::NoAction;

    [[nodiscard]] std::string column() const {
        std::string out;
        for (std::size_t i = 0; i < columns.size(); ++i) {
            if (i > 0) out += ", ";
            out += columns[i];
        }
        return out;
    }

    [[nodiscard]] std::string referencedColumn() const {
        std::string out;
        for (std::size_t i = 0; i < referencedColumns.size(); ++i) {
            if (i > 0) out += ", ";
            out += referencedColumns[i];
        }
        return out;
    }

    bool operator==(const ForeignKeyInfo&) const noexcept = default;
};

struct ConstraintInfo {
    std::string name;
    ConstraintType type = ConstraintType::Check;
    std::vector<std::string> columns;
    std::optional<std::string> definition;

    bool operator==(const ConstraintInfo&) const noexcept = default;
};

struct TableDescription {
    std::string name;
    std::optional<std::string> schema;
    std::vector<ColumnInfo> columns;
    std::vector<IndexInfo> indexes;
    std::vector<ForeignKeyInfo> foreignKeys;
    std::vector<ConstraintInfo> constraints;
    std::optional<std::string> comment;
    std::optional<int> estimatedRowCount;

    [[nodiscard]] std::vector<ColumnInfo> primaryKeyColumns() const {
        std::vector<ColumnInfo> out;
        for (const auto& c : columns) if (c.isPrimaryKey) out.push_back(c);
        return out;
    }

    [[nodiscard]] std::string toDDL(SQLDialect dialect) const {
        std::string ddl = "CREATE TABLE " + quoteIdentifier(dialect, name) + " (\n";
        for (std::size_t i = 0; i < columns.size(); ++i) {
            const auto& c = columns[i];
            ddl += "  " + c.name + " " + c.dataType;
            if (!c.isNullable) ddl += " NOT NULL";
            if (c.defaultValue) ddl += " DEFAULT " + *c.defaultValue;
            if (i + 1 < columns.size()) ddl += ",";
            ddl += "\n";
        }
        ddl += ");";
        return ddl;
    }

    bool operator==(const TableDescription&) const noexcept = default;
};

struct TableInfo {
    std::string name;
    std::optional<std::string> schema;
    TableKind type = TableKind::Table;
    std::optional<int> estimatedRowCount;
};

struct ViewInfo {
    std::string name;
    std::optional<std::string> schema;
    std::optional<std::string> definition;
    bool isMaterialized = false;
};

struct FunctionInfo {
    std::string name;
    std::optional<std::string> schema;
    std::string returnType;
    std::optional<std::string> parameters;
    std::optional<std::string> language;
};

struct EnumInfo {
    std::string name;
    std::optional<std::string> schema;
    std::vector<std::string> values;
};

struct SchemaInfo {
    std::string name;
    std::vector<TableDescription> tables;
    std::vector<ViewInfo> views;
    std::vector<FunctionInfo> functions;
    std::vector<EnumInfo> enums;
};

struct SchemaSnapshot {
    std::string databaseName;
    DatabaseType databaseType = DatabaseType::PostgreSQL;
    std::vector<SchemaInfo> schemas;
    std::chrono::system_clock::time_point capturedAt;

    [[nodiscard]] std::vector<TableDescription> allTables() const {
        std::vector<TableDescription> out;
        for (const auto& s : schemas) {
            for (const auto& t : s.tables) out.push_back(t);
        }
        return out;
    }

    [[nodiscard]] std::size_t totalTableCount() const noexcept {
        std::size_t n = 0;
        for (const auto& s : schemas) n += s.tables.size();
        return n;
    }
};

struct ColumnStatistics {
    std::string columnName;
    std::optional<int> distinctCount;
    std::optional<double> nullRatio;
    std::optional<std::vector<std::string>> topValues;
    std::optional<std::string> minValue;
    std::optional<std::string> maxValue;
};

struct QueryStatisticsEntry {
    std::string query;
    int callCount = 0;
    std::chrono::duration<double> totalTime{};
    std::chrono::duration<double> meanTime{};
    std::chrono::duration<double> minTime{};
    std::chrono::duration<double> maxTime{};
};

}