include/matador/query/basic_schema.hpp

@@ -14,10 +14,6 @@
 #include <typeindex>
 #include <unordered_map>
 
-namespace matador::sql {
-class connection;
-}
-
 namespace matador::query {
 class schema_node final {
 public:
@@ -77,9 +73,6 @@ public:
   basic_schema();
   explicit basic_schema(const std::string &name);
 
-  [[nodiscard]] utils::result<void, utils::error> create(const sql::connection &conn) const;
-  [[nodiscard]] utils::result<void, utils::error> drop(const sql::connection &conn) const;
-
   iterator begin();
   iterator end();
   [[nodiscard]] const_iterator begin() const;
@@ -96,8 +89,8 @@ public:
 
   [[nodiscard]] bool contains(const std::type_index &index) const;
 
-  [[nodiscard]] const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>>& resolver_producers() const;
-  [[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash>& collection_resolver_producers() const;
+  const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>>& resolver_producers() const;
+  const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash>& collection_resolver_producers() const;
 
 protected:
   template<typename Type>

include/matador/query/schema.hpp

@@ -227,6 +227,9 @@ public:
     return repo_.attach<Type, SuperType>(name, schema_observer<Type>{*this}, std::forward<Observers>(observers)...);
   }
 
+  [[nodiscard]] utils::result<void, utils::error> create(const sql::connection &conn) const;
+  [[nodiscard]] utils::result<void, utils::error> drop(const sql::connection &conn) const;
+
   template<typename Type>
   [[nodiscard]] utils::result<void, utils::error> drop_table(const sql::connection &conn);
   [[nodiscard]] static utils::result<void, utils::error> drop_table(const std::string &table_name, const sql::connection &conn);
@@ -251,6 +254,9 @@ public:
   void dump(std::ostream &os) const;
 
 private:
+  [[nodiscard]] static sql::query_context build_add_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::dialect &d) ;
+  [[nodiscard]] static sql::query_context build_drop_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::dialect &d) ;
+
   iterator insert_table(const std::type_index& ti, const object::repository_node &node, utils::generator_type generator_type);
 
 private:

source/orm/query/basic_schema.cpp

@@ -1,27 +1,8 @@
 #include "matador/query/basic_schema.hpp"
 
-#include "matador/query/query.hpp"
-
-#include "matador/sql/connection.hpp"
+#include "matador/sql/executor.hpp"
 
 namespace matador::query {
-namespace detail {
-sql::query_context build_add_constraint_context(const object::repository_node &node,
-                                                const object::restriction &cons,
-                                                const sql::dialect &d);
-sql::query_context build_drop_constraint_context(const object::repository_node &node,
-                                                 const object::restriction &cons,
-                                                 const sql::dialect &d);
-utils::result<void, utils::error> create_tables(const object::repository &repo, const sql::connection &conn);
-utils::result<void, utils::error> create_primary_key_constraints(const object::repository &repo, const sql::connection &conn);
-utils::result<void, utils::error> create_foreign_key_constraints(const object::repository &repo, const sql::connection &conn);
-utils::result<void, utils::error> drop_tables(const object::repository &repo, const sql::connection &conn);
-utils::result<void, utils::error> drop_primary_key_constraints(const object::repository &repo, const sql::connection &conn);
-utils::result<void, utils::error> drop_foreign_key_constraints(const object::repository &repo, const sql::connection &conn);
-utils::result<void, utils::error> setup_primary_key_generator(const basic_schema &scm, const sql::connection &conn);
-utils::result<void, utils::error> cleanup_primary_key_generator(const basic_schema &scm, const sql::connection &conn);
-}
-
 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))
@@ -51,25 +32,6 @@ 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;
-
-  return detail::create_tables(repo_, conn)
-    .and_then([this, &conn]{ return detail::create_primary_key_constraints(repo_, conn);})
-    .and_then([this, &conn]{ return detail::create_foreign_key_constraints(repo_, conn);})
-    .and_then([this, &conn]{ return detail::setup_primary_key_generator(*this, conn);});
-}
-
-utils::result<void, utils::error> basic_schema::drop(const sql::connection &conn) const {
-  return detail::drop_primary_key_constraints(repo_, conn)
-    .and_then([this, &conn]{ return detail::drop_foreign_key_constraints(repo_, conn);})
-    .and_then([this, &conn]{ return detail::drop_tables(repo_, conn);})
-    .and_then([this, &conn]{ return detail::cleanup_primary_key_generator(*this, conn);});
-}
-
 basic_schema::iterator basic_schema::begin() {
   return schema_nodes_.begin();
 }
@@ -131,166 +93,4 @@ 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_;
 }
-
-namespace detail {
-utils::result<void, utils::error> create_tables(const object::repository &repo, const sql::connection &conn) {
-  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());
-    }
-  }
-
-  return utils::ok<void>();
-}
-
-sql::query_context 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 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);
-}
-
-utils::result<void, utils::error> create_primary_key_constraints(const object::repository &repo, const sql::connection &conn) {
-  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> create_foreign_key_constraints(const object::repository &repo, const sql::connection &conn) {
-  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 (const auto result = conn.execute(ctx); !result) {
-        return utils::failure(result.err());
-      }
-    }
-  }
-
-  return utils::ok<void>();
-}
-
-utils::result<void, utils::error> drop_tables(const object::repository& repo, const sql::connection& conn) {
-  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> drop_primary_key_constraints(const object::repository& repo, const sql::connection& conn) {
-  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());
-      }
-    }
-  }
-
-  return utils::ok<void>();
-}
-
-utils::result<void, utils::error> drop_foreign_key_constraints(const object::repository& repo, const sql::connection& conn) {
-  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());
-      }
-    }
-  }
-
-  return utils::ok<void>();
-}
-
-utils::result<void, utils::error> setup_primary_key_generator(const basic_schema &scm, const sql::connection& conn) {
-  for (const auto & [index, node]: scm) {
-    if (node.pk_generator().type() == utils::generator_type::Sequence) {
-      const auto result = create().sequence(node.name() + "_pk_seq").execute(conn);
-      if (!result) {
-        return utils::failure(result.err());
-      }
-    } else if (node.pk_generator().type() == utils::generator_type::Table) {
-
-    }
-  }
-
-  return utils::ok<void>();
-}
-
-utils::result<void, utils::error> cleanup_primary_key_generator(const basic_schema& scm, const sql::connection& conn) {
-  for (const auto & [index, node]: scm) {
-    if (node.pk_generator().type() == utils::generator_type::Sequence) {
-      const auto result = drop().sequence(node.name() + "_pk_seq").execute(conn);
-      if (!result) {
-        return utils::failure(result.err());
-      }
-    } else if (node.pk_generator().type() == utils::generator_type::Table) {
-
-    }
-  }
-
-  return utils::ok<void>();
-}
-}
 }

source/orm/query/schema.cpp

@@ -1,3 +1,5 @@
+#include <utility>
+
 #include "matador/query/schema.hpp"
 
 #include "matador/query/query.hpp"
@@ -14,6 +16,102 @@
 
 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)
@@ -38,6 +136,33 @@ 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()) {
@@ -49,7 +174,7 @@ schema::iterator schema::insert_table(const std::type_index &ti, const object::r
       pk_generator = std::make_unique<identity_pk_generator>();
       break;
     case utils::generator_type::Sequence:
-      pk_generator = std::make_unique<sequence_pk_generator>(node.name() + "_pk_seq");
+      pk_generator = std::make_unique<sequence_pk_generator>(node.name());
       break;
     case utils::generator_type::Table:
       pk_generator = std::make_unique<table_pk_generator>("TABLE_SEQS", node.name());