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) {}
}

matador::utils::result<void, matador::utils::error> matador::orm::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;
    auto c = pool_.acquire();

    // auto result = query::query::create().schema( repo_.name() ).compile( *c );
    // std::cout << result.sql << std::endl;
    for (const auto &node: repo_) {
        auto ctx = query::query::create()
          .table(node->name(), node->info().definition().columns())
          .compile(*c);

        for ( const auto& [sql, command] : ctx.additional_commands ) {
            fk_sql_commands.push_back( sql );
        }
        std::cout << ctx.sql << std::endl;
        if (auto result = c->execute(ctx.sql); !result) {
            return utils::failure(result.err());
        }
    }

    // execute additional commands (e.g. ALTER TABLE ADD FK)
    for (const auto &sql: fk_sql_commands) {
        std::cout << sql << std::endl;
        if (auto result = c->execute(sql); !result) {
            return utils::failure(result.err());
        }
    }
    return utils::ok<void>();
}

matador::utils::result<void, matador::utils::error> matador::orm::schema::drop() const {
    std::vector<std::string> drop_sql_commands;
    auto c = pool_.acquire();
    for (const auto &node: repo_) {
        auto ctx = query::query::drop()
          .table(node->name())
          .compile(*c);

        drop_sql_commands.push_back(ctx.sql);
        // determine constraints and drop them
        for (auto it = node->info().endpoint_begin(); it != node->info().endpoint_end(); ++it) {
            const auto& endpoint = *(it->second);
            if (endpoint.type() == object::relation_type::BELONGS_TO) {
                continue;
            }
            const auto drop_fk_ctx = query::query::alter()
                .table( endpoint.node().name() )
                .drop_constraint( "FK_" + endpoint.node().name() + "_" + endpoint.foreign_endpoint()->field_name() )
                .compile(*c);
            std::cout << drop_fk_ctx.sql << std::endl;
            if (auto result = c->execute(drop_fk_ctx.sql); !result) {
                return utils::failure(result.err());
            }
        }
    }

    // execute additional commands (e.g. ALTER TABLE ADD FK)
    for (const auto &sql: drop_sql_commands) {
        std::cout << sql << std::endl;
        if (auto result = c->execute(sql); !result) {
            return utils::failure(result.err());
        }
    }
    return utils::ok<void>();
}

matador::utils::result<void, matador::utils::error> matador::orm::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>();
}

matador::utils::result<std::vector<matador::object::attribute_definition>, matador::utils::error> matador::orm::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());
}

matador::utils::result<bool, matador::utils::error> matador::orm::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);
}