query/source/orm/query/schema.cpp

#include <utility>

#include "matador/query/schema.hpp"

#include "matador/query/query.hpp"

#include "matador/object/repository_node.hpp"

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

namespace matador::query {
schema_node::schema_node(class table tab, const object::repository_node& node)
: table_(std::move(tab))
, node_(std::move(node)) {
}

const std::string & schema_node::name() const {
  return table_.name();
}

const table &schema_node::table() const {
  return table_;
}

const object::repository_node& schema_node::node() const {
  return node_;
}

schema::schema(const std::string &name)
: repo_(name) {
}

utils::result<void, utils::error> schema::create(const sql::connection &conn) 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 q = query::query::create().schema(repo_.name()).compile(conn);
  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(conn);

    std::cout << ctx.sql << std::endl;
    if (auto result = conn.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, conn);

      std::cout << ctx.sql << std::endl;
      if (auto result = conn.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, conn);

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

utils::result<void, utils::error> schema::drop(const sql::connection &conn) const {
  // 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)
          .compile(conn);

      std::cout << ctx.sql << std::endl;
      if (auto result = conn.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)
          .compile(conn);

      std::cout << ctx.sql << std::endl;
      if (auto result = conn.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(conn);

    std::cout << ctx.sql << std::endl;
    if (auto result = conn.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 sql::connection &conn) {
  auto result = query::query::drop()
      .table(table_name)
      .execute(conn);
  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 sql::connection &conn) {
  return utils::ok(conn.describe(table_name).release());
}

utils::result<bool, utils::error> schema::table_exists(const std::string &table_name, const sql::connection &conn) const {
  return conn.exists(repo_.name(), table_name);
}

schema::iterator schema::begin() {
  return schema_nodes_.begin();
}

schema::iterator schema::end() {
  return schema_nodes_.end();
}

schema::const_iterator schema::begin() const {
  return schema_nodes_.begin();
}

schema::const_iterator schema::end() const {
  return schema_nodes_.end();
}

schema::iterator schema::find(const std::string &name) {
  const auto result = repo_.basic_info(name);
  if (!result) {
    return schema_nodes_.end();
  }

  return schema_nodes_.find(result->get().type_index());
}

schema::const_iterator schema::find(const std::string &name) const {
  const auto result = repo_.basic_info(name);
  if (!result) {
    return schema_nodes_.end();
  }

  return schema_nodes_.find(result->get().type_index());
}

sql::query_context schema::build_add_constraint_context(const object::repository_node &node,
                                                        const object::restriction &cons,
                                                        const sql::connection &conn) const {
  if (cons.is_foreign_key_constraint()) {
    return query::query::alter()
        .table(node.name())
        .add_constraint(cons)
        .compile(conn);
  }
  if (cons.is_primary_key_constraint()) {
    return query::query::alter()
        .table(node.name())
        .add_constraint(cons)
        .compile(conn);
  }
  return {};
}

sql::query_context schema::build_drop_constraint_context(const object::repository_node &node,
                                                         const object::restriction &cons,
                                                         const sql::connection &conn) const {
  return query::query::alter()
      .table(node.name())
      .drop_constraint(cons)
      .compile(conn);
}

void schema::insert_table(const std::type_index &ti, const object::repository_node &node) {
  std::vector<table_column> columns;
  for (const auto &attr: node.info().attributes()) {
    columns.emplace_back(nullptr, attr.name(), attr.type(), attr.attributes());
  }
  std::ignore = schema_nodes_.insert({ti, schema_node{table(node.name(), columns), node}}).first;
}
} // namespace matador::query