query/source/orm/query/basic_schema.cpp

#include "matador/query/basic_schema.hpp"

#include "matador/query/query.hpp"

#include "matador/sql/connection.hpp"

namespace matador::query {
schema_node::schema_node(class table tab, std::unique_ptr<abstract_pk_generator> &&pk_generator, const object::repository_node& node)
: table_(std::move(tab))
, pk_generator_(std::move(pk_generator))
, node_(std::move(node)) {
}

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

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

abstract_pk_generator& schema_node::pk_generator() const {
  return *pk_generator_;
}

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

basic_schema::basic_schema()
: basic_schema("") {}

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

utils::result<void, utils::error> basic_schema::create(const sql::connection &conn) const {
  std::vector<std::string> fk_sql_commands;

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

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

    if (auto result = conn.execute(ctx); !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.dialect());

      if (auto result = conn.execute(ctx); !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.dialect());

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

utils::result<void, utils::error> basic_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 = alter()
          .table(node.name())
          .drop_constraint(cons)
          .compile(conn.dialect());

      if (auto result = conn.execute(ctx); !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 = alter()
          .table(node.name())
          .drop_constraint(cons)
          .compile(conn.dialect());

      if (auto result = conn.execute(ctx); !result) {
        return utils::failure(result.err());
      }
    }
  }

  // drop table
  for (const auto &node: repo_) {
    auto ctx = query::drop()
        .table(node.name())
        .compile(conn.dialect());

    if (auto result = conn.execute(ctx); !result) {
      return utils::failure(result.err());
    }
  }

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

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

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

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

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

size_t basic_schema::size() const {
  return schema_nodes_.size();
}

bool basic_schema::empty() const {
  return schema_nodes_.empty();
}

basic_schema::iterator basic_schema::find(const std::type_index &ti) {
  return schema_nodes_.find(ti);
}

basic_schema::const_iterator basic_schema::find(const std::type_index &ti) const {
  return schema_nodes_.find(ti);
}

basic_schema::iterator basic_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());
}

basic_schema::const_iterator basic_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());
}

bool basic_schema::contains(const std::type_index &index) const {
  return schema_nodes_.count(index) == 1;
}

const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>> & basic_schema::resolver_producers() const {
  return resolver_producers_;
}

const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash> & basic_schema::collection_resolver_producers() const {
  return collection_resolver_producers_;
}

sql::query_context basic_schema::build_add_constraint_context(const object::repository_node &node,
                                                        const object::restriction &cons,
                                                        const sql::dialect &d) {
  if (cons.is_foreign_key_constraint()) {
    return alter()
        .table(node.name())
        .add_constraint(cons)
        .compile(d);
  }
  if (cons.is_primary_key_constraint()) {
    return alter()
        .table(node.name())
        .add_constraint(cons)
        .compile(d);
  }
  return {};
}

sql::query_context basic_schema::build_drop_constraint_context(const object::repository_node &node,
                                                         const object::restriction &cons,
                                                         const sql::dialect &d) {
  return alter()
      .table(node.name())
      .drop_constraint(cons)
      .compile(d);
}
}