moved create and drop methods to basic_schema

source/orm/query/basic_schema.cpp

@@ -1,6 +1,8 @@
 #include "matador/query/basic_schema.hpp"
 
-#include "matador/sql/executor.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)
@@ -32,6 +34,102 @@ 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();
 }
@@ -93,4 +191,31 @@ const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_p
 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);
+}
 }

source/orm/query/schema.cpp

@@ -1,5 +1,3 @@
-#include <utility>
-
 #include "matador/query/schema.hpp"
 
 #include "matador/query/query.hpp"
@@ -16,102 +14,6 @@
 
 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.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> 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>();
-}
-
 utils::result<void, utils::error> schema::drop_table(const std::string &table_name, const sql::connection &conn) {
   auto result = query::drop()
       .table(table_name)
@@ -136,33 +38,6 @@ 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::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 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);
-}
-
 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()) {