From 8e1dbe2ccd67d151b1180a488452646c5d99dff3 Mon Sep 17 00:00:00 2001
From: sascha <skuehl1972@gmail.com>
Date: Wed, 29 Apr 2026 12:57:23 +0200
Subject: [PATCH] moved create and drop methods to basic_schema

---
 include/matador/query/basic_schema.hpp |  15 ++-
 include/matador/query/schema.hpp       |   6 --
 source/orm/query/basic_schema.cpp      | 127 ++++++++++++++++++++++++-
 source/orm/query/schema.cpp            | 125 ------------------------
 4 files changed, 139 insertions(+), 134 deletions(-)

diff --git a/include/matador/query/basic_schema.hpp b/include/matador/query/basic_schema.hpp
index 7360e28..7ab64d8 100644
--- a/include/matador/query/basic_schema.hpp
+++ b/include/matador/query/basic_schema.hpp
@@ -14,6 +14,10 @@
 #include <typeindex>
 #include <unordered_map>
 
+namespace matador::sql {
+class connection;
+}
+
 namespace matador::query {
 class schema_node final {
 public:
@@ -73,6 +77,9 @@ 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;
@@ -89,8 +96,12 @@ public:
 
   [[nodiscard]] bool contains(const std::type_index &index) 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;
+  [[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;
+
+protected:
+  [[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) ;
 
 protected:
   template<typename Type>
diff --git a/include/matador/query/schema.hpp b/include/matador/query/schema.hpp
index 1503759..3b7d1ad 100644
--- a/include/matador/query/schema.hpp
+++ b/include/matador/query/schema.hpp
@@ -227,9 +227,6 @@ 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);
@@ -254,9 +251,6 @@ 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:
diff --git a/source/orm/query/basic_schema.cpp b/source/orm/query/basic_schema.cpp
index 1cb114a..89c7cf2 100644
--- a/source/orm/query/basic_schema.cpp
+++ b/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);
+}
 }
diff --git a/source/orm/query/schema.cpp b/source/orm/query/schema.cpp
index 0f2b70b..2d9db5f 100644
--- a/source/orm/query/schema.cpp
+++ b/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()) {