From 3fb23e167ec763ce8dab1d7250225c928c951786 Mon Sep 17 00:00:00 2001
From: sascha <skuehl1972@gmail.com>
Date: Wed, 29 Apr 2026 14:07:17 +0200
Subject: [PATCH] fixed pk sequence tests

---
 include/matador/query/basic_schema.hpp |   4 -
 source/orm/query/basic_schema.cpp      | 257 ++++++++++++++++---------
 source/orm/query/schema.cpp            |   2 +-
 3 files changed, 167 insertions(+), 96 deletions(-)

diff --git a/include/matador/query/basic_schema.hpp b/include/matador/query/basic_schema.hpp
index 7ab64d8..aa024fb 100644
--- a/include/matador/query/basic_schema.hpp
+++ b/include/matador/query/basic_schema.hpp
@@ -99,10 +99,6 @@ public:
   [[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>
   friend class schema_observer;
diff --git a/source/orm/query/basic_schema.cpp b/source/orm/query/basic_schema.cpp
index 89c7cf2..bb1f40c 100644
--- a/source/orm/query/basic_schema.cpp
+++ b/source/orm/query/basic_schema.cpp
@@ -5,6 +5,23 @@
 #include "matador/sql/connection.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))
@@ -40,94 +57,17 @@ utils::result<void, utils::error> basic_schema::create(const sql::connection &co
   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>();
+  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 {
-  // 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>();
+  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() {
@@ -192,9 +132,25 @@ const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::
   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) {
+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())
@@ -210,12 +166,131 @@ sql::query_context basic_schema::build_add_constraint_context(const object::repo
   return {};
 }
 
-sql::query_context basic_schema::build_drop_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) {
   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>();
+}
+}
 }
diff --git a/source/orm/query/schema.cpp b/source/orm/query/schema.cpp
index 2d9db5f..53d8fef 100644
--- a/source/orm/query/schema.cpp
+++ b/source/orm/query/schema.cpp
@@ -49,7 +49,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_generator = std::make_unique<sequence_pk_generator>(node.name() + "_pk_seq");
       break;
     case utils::generator_type::Table:
       pk_generator = std::make_unique<table_pk_generator>("TABLE_SEQS", node.name());