query/source/orm/orm/schema.cpp

#include "matador/orm/schema.hpp"

#include "matador/orm/error_code.hpp"
#include "matador/orm/session.hpp"

#include "matador/query/query.hpp"

#include "matador/sql/backend_provider.hpp"
#include "matador/sql/connection_pool.hpp"
#include "matador/sql/dialect.hpp"

namespace matador::orm {
schema::schema(sql::connection_pool& pool)
: repo_(sql::backend_provider::instance().connection_dialect(pool.info().type).default_schema_name())
, pool_(pool) {
}

schema::schema(sql::connection_pool &pool, const std::string& name)
: repo_(name)
, pool_(pool) {}

utils::result<void, utils::error> schema::create() const {
    // Step 1: Build dependency graph
    // std::unordered_map<std::string, std::vector<std::string> > dependency_graph;
    // std::unordered_map<std::string, std::pair<int,object::repository::node_ptr>> in_degree;
    //
    // for (const auto &node: repo_) {
    //     for (auto it = node->info().endpoint_begin(); it != node->info().endpoint_end(); ++it) {
    //         dependency_graph[node->name()].push_back(it->second->node().name());
    //
    //         if (const auto dit = in_degree.find(it->second->node().name()); dit == in_degree.end()) {
    //             in_degree[it->second->node().name()] = std::make_pair(1, it->second->node_ptr());
    //         } else {
    //             in_degree[it->second->node().name()].first++;
    //         }
    //     }
    //
    //     // Ensure the current node exists in the graph representation
    //     if (in_degree.find(node->name()) == in_degree.end()) {
    //         in_degree[node->name()] = std::make_pair(0, node);
    //     }
    // }
    //
    // for (const auto &it : dependency_graph) {
    //     std::cout << "Dependency graph " << it.first << std::endl;
    //     for (const auto &neighbor: it.second) {
    //         std::cout << "  " << neighbor << std::endl;
    //     }
    //     std::cout << std::endl;
    // }

    std::vector<std::string> fk_sql_commands;
    const auto c = pool_.acquire();

    const auto q = query::query::create().schema( repo_.name() ).compile( *c );
    std::cout << q.sql << std::endl;

    // create plain tables without constraints
    for (const auto &node: repo_) {
        auto ctx = query::query::create()
          .table(node->name())
          .columns(node->info().attributes())
          // .constraints(node->info().constraints())
          .compile(*c);

        std::cout << ctx.sql << std::endl;
        if (auto result = c->execute(ctx.sql); !result) {
            return utils::failure(result.err());
        }
    }

    // create primary key constraints
    for (const auto &node: repo_) {
        for (const auto& cons : node->info().constraints()) {
            if (!cons.is_primary_key_constraint()) {
                continue;
            }
            auto ctx = build_add_constraint_context(*node, cons);

            std::cout << ctx.sql << std::endl;
            if (auto result = c->execute(ctx.sql); !result) {
                return utils::failure(result.err());
            }
        }
    }
    // create table constraints
    for (const auto &node: repo_) {
        for (const auto& cons : node->info().constraints()) {
            if (cons.is_primary_key_constraint()) {
                continue;
            }
            auto ctx = build_add_constraint_context(*node, cons);

            std::cout << ctx.sql << std::endl;
            if (auto result = c->execute(ctx.sql); !result) {
                return utils::failure(result.err());
            }
        }
    }
    return utils::ok<void>();
}

utils::result<void, utils::error> schema::drop() const {
    auto c = pool_.acquire();
    // drop table primary key constraints
    for (const auto &node: repo_) {
        for (const auto& cons : node->info().constraints()) {
            if (cons.is_primary_key_constraint()) {
                continue;
            }
            auto ctx = query::query::alter()
              .table(node->name())
              .drop_constraint("cons.name()")
              .compile(*c);

            std::cout << ctx.sql << std::endl;
            if (auto result = c->execute(ctx.sql); !result) {
                return utils::failure(result.err());
            }
        }
    }

    // drop table constraints
    for (const auto &node: repo_) {
        for (const auto& cons : node->info().constraints()) {
            if (!cons.is_primary_key_constraint()) {
                continue;
            }
            auto ctx = query::query::alter()
              .table(node->name())
              .drop_constraint("cons.name()")
              .compile(*c);

            std::cout << ctx.sql << std::endl;
            if (auto result = c->execute(ctx.sql); !result) {
                return utils::failure(result.err());
            }
        }
    }

    // drop table
    for (const auto &node: repo_) {
        auto ctx = query::query::drop()
          .table(node->name())
          .compile(*c);

        std::cout << ctx.sql << std::endl;
        if (auto result = c->execute(ctx.sql); !result) {
            return utils::failure(result.err());
        }
    }

    return utils::ok<void>();
}

utils::result<void, utils::error> schema::drop_table(const std::string& table_name) const {
    const auto c = pool_.acquire();
    auto result = query::query::drop()
      .table(table_name)
      .execute(*c);
    if (result.is_error()) {
        return utils::failure(result.err());
    }

    return utils::ok<void>();
}

utils::result<std::vector<object::attribute>, utils::error> schema::describe_table(const std::string& table_name) const {
    const auto c = pool_.acquire();
    if (!c.valid()) {
        return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
    }
    return utils::ok(c->describe(table_name).release());
}

utils::result<bool, utils::error> schema::table_exists(const std::string& table_name) const {
    const auto c = pool_.acquire();
    if (!c.valid()) {
        return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
    }
    return c->exists(repo_.name(), table_name);
}

sql::query_context schema::build_add_constraint_context( const object::repository_node& node, const class object::restriction& cons ) const {
  if (cons.is_foreign_key_constraint()) {
    return query::query::alter()
      .table(node.name())
      .add_constraint("cons.name()")
      .foreign_key(cons.column_name())
      .references(cons.ref_table_name(), {cons.ref_column_name()})
      .compile(*pool_.acquire());
  }
  if (cons.is_primary_key_constraint()) {
      return query::query::alter()
      .table(node.name())
      .add_constraint("cons.name()")
      .primary_key(cons.column_name())
      .compile(*pool_.acquire());
  }
  return {};
}

sql::query_context schema::build_drop_constraint_context( const object::repository_node& node, const class object::restriction& cons ) const {
    return query::query::alter()
      .table(node.name())
      .drop_constraint("cons.name()")
      .compile(*pool_.acquire());
}
}