added more pk generator types

include/matador/query/abstract_pk_generator.hpp

@@ -3,6 +3,7 @@
 
 #include "matador/utils/error.hpp"
 #include "matador/utils/result.hpp"
+#include "matador/utils/primary_key_generator_type.hpp"
 
 #include <cstdint>
 
@@ -14,6 +15,14 @@ class abstract_pk_generator {
 public:
   virtual ~abstract_pk_generator() = default;
   virtual utils::result<int64_t, utils::error> next_id(const sql::executor& exec) = 0;
+
+  [[nodiscard]] utils::generator_type type() const;
+
+protected:
+  explicit abstract_pk_generator(utils::generator_type type);
+
+private:
+  utils::generator_type generator_type_{};
 };
 }
 #endif //MATADOR_ABSTRACT_PK_GENERATOR_HPP

include/matador/query/basic_schema.hpp

@@ -1,31 +1,33 @@
 #ifndef MATADOR_BASIC_SCHEMA_HPP
 #define MATADOR_BASIC_SCHEMA_HPP
 
-#include <memory>
-#include <typeindex>
-#include <unordered_map>
-
 #include "matador/object/repository.hpp"
 
+#include "matador/query/abstract_pk_generator.hpp"
 #include "matador/query/table.hpp"
 
 #include "matador/sql/internal/collection_resolver_producer.hpp"
 #include "matador/sql/internal/object_resolver_producer.hpp"
 #include "matador/sql/producer_resolver_factory.hpp"
 
+#include <memory>
+#include <typeindex>
+#include <unordered_map>
+
 namespace matador::query {
 class schema_node final {
 public:
-  schema_node(class table tab, utils::generator_type generator_type, const object::repository_node& node);
+  schema_node(class table tab, std::unique_ptr<abstract_pk_generator> &&pk_generator, const object::repository_node& node);
 
   [[nodiscard]] const std::string& name() const;
   [[nodiscard]] const class table& table() const;
-  [[nodiscard]] utils::generator_type generator_type() const;
+  [[nodiscard]] abstract_pk_generator& pk_generator() const;
   [[nodiscard]] const object::repository_node& node() const;
 
 private:
   class table table_;
   utils::generator_type generator_type_{};
+  std::unique_ptr<abstract_pk_generator> pk_generator_;
   const object::repository_node& node_;
 };
 
@@ -33,7 +35,7 @@ class primary_key_generator_finder final {
 public:
   template< typename Type >
   utils::generator_type find(const object::object_info<Type>& info) {
-    generator_type_ = utils::generator_type::Manually;
+    generator_type_ = utils::generator_type::Manual;
 
     access::process(*this, info.prototype());
 

include/matador/query/database.hpp

@@ -0,0 +1,20 @@
+#ifndef MATADOR_DATABASE_HPP
+#define MATADOR_DATABASE_HPP
+
+#include "matador/query/schema.hpp"
+#include "matador/utils/result.hpp"
+#include "matador/utils/error.hpp"
+
+namespace matador::query {
+class database final {
+public:
+  utils::result<void, utils::error> add(const std::string &name, const schema &schema);
+  utils::result<void, utils::error> remove(const std::string &name);
+
+  [[nodiscard]] utils::result<schema_ref, utils::error> get(const std::string &name);
+
+private:
+  std::unordered_map<std::string, schema> schema_map_;
+};
+}
+#endif //MATADOR_DATABASE_HPP

include/matador/query/insert_query_builder.hpp

@@ -89,7 +89,7 @@ public:
     step_query_t query;
 
     // Session uses these to handle manual/sequence/table pre-insert PKs
-    utils::generator_type pk_generator{utils::generator_type::Manually};
+    utils::generator_type pk_generator{utils::generator_type::Manual};
     std::string pk_name;
 
     std::function<bool()> pk_is_unset{};
@@ -228,7 +228,7 @@ private:
     insert_step step{};
     if (info.has_primary_key()) {
       step.pk_name = info.primary_key_attribute()->name();
-      step.pk_generator = it->second.generator_type();
+      step.pk_generator = it->second.pk_generator().type();
 
       step.pk_is_unset = [ptr, name = step.pk_name]() {
         pk_unset_checker chk{name};

include/matador/query/manual_pk_generator.hpp

@@ -0,0 +1,13 @@
+#ifndef MATADOR_MANUAL_PK_GENERATOR_HPP
+#define MATADOR_MANUAL_PK_GENERATOR_HPP
+
+#include "matador/query/abstract_pk_generator.hpp"
+
+namespace matador::query {
+class manual_pk_generator : public abstract_pk_generator {
+public:
+    manual_pk_generator();
+    [[nodiscard]] utils::result<int64_t, utils::error> next_id(const sql::executor& exec) override;
+};
+}
+#endif //MATADOR_MANUAL_PK_GENERATOR_HPP

include/matador/query/schema.hpp

@@ -183,17 +183,6 @@ class schema;
 
 using schema_ref = std::reference_wrapper<schema>;
 
-class schema_repository final {
-public:
-    utils::result<void, utils::error> add(const std::string &name, const schema &schema);
-    utils::result<void, utils::error> remove(const std::string &name);
-
-    [[nodiscard]] utils::result<schema_ref, utils::error> get(const std::string &name);
-
-private:
-    std::unordered_map<std::string, schema> schema_map_;
-};
-
 template<typename Type>
 class schema_observer final : public object::observer<Type> {
 public:

include/matador/query/table_pk_generator.hpp

@@ -0,0 +1,16 @@
+#ifndef MATADOR_TABLE_PK_GENERATOR_HPP
+#define MATADOR_TABLE_PK_GENERATOR_HPP
+
+#include "matador/query/abstract_pk_generator.hpp"
+
+namespace matador::query {
+class table_pk_generator : public abstract_pk_generator {
+public:
+    table_pk_generator(const std::string& table_name, const std::string& sequence_name);
+    [[nodiscard]] utils::result<int64_t, utils::error> next_id(const sql::executor& exec) override;
+
+private:
+    std::string table_name;
+};
+}
+#endif //MATADOR_TABLE_PK_GENERATOR_HPP