query/source/orm/query/schema.cpp

#include <utility>

#include "matador/query/schema.hpp"

#include "matador/query/query.hpp"
#include "matador/query/manual_pk_generator.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 {

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

  const auto q = 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())
        .compile(conn);

    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);

      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);

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

      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 = query::query::alter()
          .table(node.name())
          .drop_constraint(cons)
          .compile(conn);

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

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

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

void schema::dump(std::ostream &os) const {
  repo_.dump(os);
}

sql::query_context schema::build_add_constraint_context(const object::repository_node &node,
                                                        const object::restriction &cons,
                                                        const sql::connection &conn) {
  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) {
  return query::query::alter()
      .table(node.name())
      .drop_constraint(cons)
      .compile(conn);
}

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