changed the interface of on_primary_key to have a third parameter of type primary_key_attribute

include/matador/object/attribute_definition_generator.hpp

@@ -7,6 +7,7 @@
 #include "matador/utils/data_type_traits.hpp"
 #include "matador/utils/error.hpp"
 #include "matador/utils/field_attributes.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 
 #include <memory>
@@ -29,10 +30,9 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *, ValueType &/*pk*/, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr) {
+  void on_primary_key(const char *, ValueType &/*pk*/, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
-    type_ = utils::data_type_traits<ValueType>::type(0);
+    type_ = utils::data_type_traits<ValueType>::type(attr.size());
   }
-  void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t size);
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template < class Type >
   static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
@@ -77,9 +77,8 @@ public:
     return columns;
   }
 
-  template < class V >
+  template < class Type >
-  void on_primary_key(const char *, V &x, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr);
+  void on_primary_key(const char *, Type &x, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
-  void on_primary_key(const char *id, std::string &pk, size_t size);
   void on_revision(const char *id, uint64_t &rev);
 
   template<typename Type>
@@ -133,10 +132,9 @@ private:
   fk_attribute_generator fk_column_generator_;
 };
 
-template<typename V>
+template<typename ValueType>
-void attribute_definition_generator::on_primary_key(const char *id, V &x, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>*)
+void attribute_definition_generator::on_primary_key(const char *id, ValueType &x, const utils::primary_key_attribute& attr) {
-{
+  on_attribute(id, x, { attr.size(), utils::constraints::PRIMARY_KEY });
-  on_attribute(id, x, { utils::constraints::PRIMARY_KEY });
 }
 
 template<typename Type>

include/matador/object/foreign_node_completer.hpp

@@ -6,6 +6,8 @@
 #include "matador/object/join_columns_collector.hpp"
 #include "matador/object/object_ptr.hpp"
 
+#include "matador/utils/primary_key_attribute.hpp"
+
 #include "matador/logger/log_manager.hpp"
 
 #include <stack>
@@ -33,8 +35,7 @@ public:
     }
 
     template<class PrimaryKeyType>
-    static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>> * = nullptr) {}
+    static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
-    static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
     static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
     template<typename AttributeType>
     static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}

include/matador/object/join_columns_collector.hpp

@@ -3,6 +3,7 @@
 
 #include "matador/utils/access.hpp"
 #include "matador/utils/field_attributes.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 #include <string>
 
@@ -24,8 +25,7 @@ public:
         return join_columns_;
     }
     template < class V >
-    void on_primary_key(const char * /*id*/, V &, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr) {}
+    static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
-    static void on_primary_key(const char * /*id*/, std::string &, size_t) {}
     static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
     template<typename Type>
     static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}

include/matador/object/primary_key_resolver.hpp

@@ -5,6 +5,7 @@
 #include "matador/utils/field_attributes.hpp"
 #include "matador/utils/foreign_attributes.hpp"
 #include "matador/utils/identifier.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 #include <cstdint>
 #include <string>
@@ -42,14 +43,12 @@ public:
   }
 
   template < class Type >
-  void on_primary_key(const char *id, Type &pk, std::enable_if_t<std::is_integral_v<Type> && !std::is_same_v<bool, Type>>* = nullptr) {
+  void on_primary_key(const char *id, Type &pk, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
     primary_key_info_.pk_column_name = id;
-    primary_key_info_.type = utils::data_type_traits<Type>::type();
+    primary_key_info_.type = utils::data_type_traits<Type>::type(attr.size());
     primary_key_info_.pk = pk;
   }
 
-  void on_primary_key(const char *id, const std::string &pk, size_t size);
-
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template<typename Type>
   static void on_attribute(const char * /*id*/, Type &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}

include/matador/object/relation_completer.hpp

@@ -9,6 +9,8 @@
 
 #include "matador/logger/log_manager.hpp"
 
+#include "matador/utils/primary_key_attribute.hpp"
+
 #include <iostream>
 #include <stack>
 #include <utility>
@@ -27,8 +29,7 @@ public:
     }
 
     template<class PrimaryKeyType>
-    static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>> * = nullptr) {}
+    static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
-    static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
     static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
     template<typename AttributeType>
     static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
@@ -106,8 +107,7 @@ public:
   }
 
   template<class PrimaryKeyType>
-  static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>> * = nullptr) {}
+  static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
-  static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
   static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
   template<typename AttributeType>
   static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}

include/matador/orm/session_insert_builder.hpp

@@ -9,6 +9,7 @@
 #include "matador/object/schema.hpp"
 
 #include "matador/utils/cascade_type.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 namespace matador::orm {
 struct entity_insert_data {
@@ -62,11 +63,10 @@ public:
   }
 
   template<class V>
-  void on_primary_key(const char *id, V &x, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>> * = nullptr) {
+  void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
     push(id, x);
   }
 
-  void on_primary_key(const char *id, std::string &, size_t);
   void on_revision(const char *id, unsigned long long &/*rev*/);
 
   template<typename Type>

include/matador/orm/session_query_builder.hpp

@@ -11,6 +11,7 @@
 #include "matador/object/join_columns_collector.hpp"
 #include "matador/object/schema.hpp"
 
+#include "matador/utils/primary_key_attribute.hpp"
 #include "matador/utils/result.hpp"
 #include "matador/utils/value.hpp"
 
@@ -76,7 +77,7 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr)
+  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes)
   {
     push(id);
     if (!is_root_entity()) {
@@ -90,10 +91,11 @@ public:
       auto co = std::make_unique<query::condition<sql::column, V>>(c, query::basic_condition::operand_type::EQUAL, v);
       entity_query_data_.where_clause = std::move(co);
       entity_query_data_.pk_column_name = id;
+    } else if (pk_.is_varchar()) {
+      // Todo: handle varchar primary key
     }
   }
 
-  void on_primary_key(const char *id, std::string &, size_t);
   void on_revision(const char *id, unsigned long long &/*rev*/);
 
   template<typename Type>

include/matador/query/fk_value_extractor.hpp

@@ -4,6 +4,7 @@
 #include "matador/utils/access.hpp"
 #include "matador/utils/field_attributes.hpp"
 #include "matador/utils/foreign_attributes.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 #include "matador/utils/types.hpp"
 
 namespace matador::query::detail {
@@ -21,26 +22,23 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *, ValueType &pk, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr)
+  void on_primary_key(const char *, ValueType &pk, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
-  {
     value_ = pk;
   }
-  void on_primary_key(const char * /*id*/, std::string &pk, size_t size);
+  static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
-  void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
   template < class Type >
-  void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
-  void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
   template<class Pointer>
-  void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
+  static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
   template<class Pointer>
-  void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
+  static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char *, ContainerType &, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
+  static void on_has_many_to_many(const char *, ContainerType &, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char *, ContainerType &, const utils::foreign_attributes &/*attr*/) {}
+  static void on_has_many_to_many(const char *, ContainerType &, const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many(const char *, ContainerType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
+  static void on_has_many(const char *, ContainerType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
-
 
 private:
   utils::database_type value_{};

include/matador/query/key_value_generator.hpp

@@ -5,6 +5,7 @@
 #include "matador/query/internal/key_value_pair.hpp"
 
 #include "matador/utils/foreign_attributes.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 #include <vector>
 
@@ -28,11 +29,9 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &x, typename std::enable_if<std::is_integral<V>::value && !std::is_same<bool, V>::value>::type* = 0)
+  void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
-  {
     result_.emplace_back(id, x);
   }
-  void on_primary_key(const char *id, std::string &, size_t);
   void on_revision(const char *id, unsigned long long &/*rev*/);
 
   template<typename Type>

include/matador/query/value_extractor.hpp

@@ -5,6 +5,7 @@
 
 #include "matador/utils/attribute_writer.hpp"
 #include "matador/utils/default_type_traits.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 #include <vector>
 
@@ -25,11 +26,9 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *, ValueType &x, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr)
+  void on_primary_key(const char *, ValueType &x, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
-  {
+    utils::data_type_traits<ValueType>::bind_value(*this, 0, x, attr.size());
-    utils::data_type_traits<ValueType>::bind_value(*this, 0, x);
   }
-  void on_primary_key(const char *id, std::string &pk, size_t size);
   void on_revision(const char *id, uint64_t &rev);
   template < class Type >
   void on_attribute(const char *, Type &x, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
@@ -48,15 +47,15 @@ public:
     values_.emplace_back(fk_value_extractor_.extract(*x));
   }
   template<class ContainerType>
-  void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
+  static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const char * /*join_column*/,
                                   const char * /*inverse_join_column*/,
                                   const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const utils::foreign_attributes &/*attr*/) {}
 

include/matador/sql/column_generator.hpp

@@ -4,6 +4,7 @@
 #include "matador/utils/access.hpp"
 #include "matador/utils/field_attributes.hpp"
 #include "matador/utils/foreign_attributes.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 #include "matador/sql/column.hpp"
 
@@ -52,13 +53,12 @@ public:
   }
 
   template < class V >
-  void on_primary_key(const char *id, V &, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr) {
+  void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
       if (has_many_to_many_) {
           return;
       }
       push(id);
   }
-  void on_primary_key(const char *id, std::string &, size_t);
   void on_revision(const char *id, unsigned long long &/*rev*/);
 
   template<typename Type>

include/matador/sql/internal/object_result_binder.hpp

@@ -7,6 +7,7 @@
 #include "matador/utils/access.hpp"
 #include "matador/utils/field_attributes.hpp"
 #include "matador/utils/foreign_attributes.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 namespace matador::sql {
 
@@ -27,30 +28,29 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *id, ValueType &value, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr);
+  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
-  void on_primary_key(const char *id, std::string &value, size_t size);
+  static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
-  void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
 
   template < class Type >
-  void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
   template < class Pointer >
-  void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
+  static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
   template < class Pointer >
-  void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
+  static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
 
   template<class ContainerType>
-  void on_has_many(const char * /*id*/,
+  static void on_has_many(const char * /*id*/,
                           ContainerType &/*c*/,
                           const char * /*join_column*/,
                           const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const char * /*join_column*/,
                                   const char * /*inverse_join_column*/,
                                   const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const utils::foreign_attributes &/*attr*/) {}
 
@@ -74,16 +74,13 @@ public:
   void reset();
 
   template < class Type >
-  void on_primary_key(const char *id, Type &val, std::enable_if_t<std::is_integral_v<Type> && !std::is_same_v<bool, Type>>* = nullptr)
+  void on_primary_key(const char *id, Type &val, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
-  {
+    utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val, attr.size());
-    utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val);
   }
-  void on_primary_key(const char *id, std::string &, size_t size);
   void on_revision(const char *id, uint64_t &/*rev*/);
 
   template<typename Type>
-  void on_attribute(const char *id, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes)
+  void on_attribute(const char *id, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
-  {
     utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val);
   }
   void on_attribute(const char *id, char *value, const utils::field_attributes &attr = utils::null_attributes);
@@ -91,28 +88,26 @@ public:
   void on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr = utils::null_attributes);
 
   template<class Type, template < class ... > class Pointer>
-  void on_belongs_to(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes)
+  void on_belongs_to(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {
-  {
     fk_result_binder_.bind(*x, id, index_++, *binder_);
   }
   template<class Type, template < class ... > class Pointer>
-  void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes)
+  void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {
-  {
     fk_result_binder_.bind(*x, id, index_++, *binder_);
   }
   template<class ContainerType>
-  void on_has_many(const char * /*id*/,
+  static void on_has_many(const char * /*id*/,
                           ContainerType &/*c*/,
                           const char * /*join_column*/,
                           const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const char * /*join_column*/,
                                   const char * /*inverse_join_column*/,
                                   const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const utils::foreign_attributes &/*attr*/) {}
 
@@ -125,9 +120,8 @@ private:
 namespace detail {
 
 template<typename ValueType>
-void fk_result_binder::on_primary_key(const char * /*id*/, ValueType &value, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> *)
+void fk_result_binder::on_primary_key(const char * /*id*/, ValueType &value, const utils::primary_key_attribute& attr) {
-{
+  utils::data_type_traits<ValueType>::read_value(*binder_, id_, index_++, value, attr.size());
-  utils::data_type_traits<ValueType>::read_value(*binder_, id_, index_++, value);
 }
 
 }

include/matador/sql/internal/query_result_impl.hpp

@@ -6,6 +6,7 @@
 #include "matador/utils/foreign_attributes.hpp"
 #include "matador/utils/default_type_traits.hpp"
 #include "matador/utils/identifier.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 #include "matador/sql/interface/query_result_reader.hpp"
 #include "matador/sql/internal/query_result_pk_resolver.hpp"
@@ -37,9 +38,7 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *id, ValueType &value,
+  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
-                      std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> * = nullptr);
-  void on_primary_key(const char *id, std::string &value, size_t size);
   void on_revision(const char * /*id*/, unsigned long long &/*rev*/) { ++column_index_; }
 
   template<class Type>
@@ -52,21 +51,20 @@ public:
   }
 
   template<class Pointer>
-  void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) { ++column_index_; }
+  void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {
-
+    ++column_index_;
-  template<class ContainerType>
-  void on_has_many(const char * /*id*/, ContainerType &, const char * /*join_column*/,
-                   const utils::foreign_attributes &/*attr*/) {
   }
 
   template<class ContainerType>
-  void on_has_many_to_many(const char *id, ContainerType &c, const char * /*join_column*/,
+  static void on_has_many(const char * /*id*/, ContainerType &, const char * /*join_column*/,
-                           const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {
+                          const utils::foreign_attributes &/*attr*/) {}
-  }
 
   template<class ContainerType>
-  void on_has_many_to_many(const char *id, ContainerType &c, const utils::foreign_attributes &/*attr*/) {
+  static void on_has_many_to_many(const char *id, ContainerType &c, const char * /*join_column*/,
-  }
+                                  const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
+
+  template<class ContainerType>
+  static void on_has_many_to_many(const char *id, ContainerType &c, const utils::foreign_attributes &/*attr*/) {}
 
 private:
   size_t column_index_{};
@@ -82,16 +80,14 @@ public:
                     const std::vector<object::attribute_definition> &prototype, size_t column_index = 0);
 
   template<typename ValueType>
-  void on_primary_key(const char *id, ValueType &value,
+  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
-                      std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> * = nullptr) {
+    utils::data_type_traits<ValueType>::read_value(*reader_, id, column_index_++, value, attr.size());
-    utils::data_type_traits<ValueType>::read_value(*reader_, id, column_index_++, value);
     if (type_stack_.size() == 1) {
       last_pk_ = current_pk_;
       current_pk_ = value;
     }
   }
 
-  void on_primary_key(const char *id, std::string &value, size_t size);
   void on_revision(const char *id, uint64_t &rev);
 
   template<class Type>
@@ -228,9 +224,8 @@ protected:
 
 namespace detail {
 template<typename ValueType>
-void pk_reader::on_primary_key(const char *id, ValueType &value,
+void pk_reader::on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr) {
-                               std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> *) {
+  utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_++, value, attr.size());
-  utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_++, value);
 }
 }
 }

include/matador/sql/internal/query_result_pk_resolver.hpp

@@ -5,6 +5,7 @@
 #include "matador/utils/field_attributes.hpp"
 #include "matador/utils/foreign_attributes.hpp"
 #include "matador/utils/identifier.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 #include "matador/sql/interface/query_result_reader.hpp"
 
@@ -27,15 +28,14 @@ public:
     }
 
     template<typename ValueType>
-    void on_primary_key(const char *id, ValueType &/*value*/, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr) {
+    void on_primary_key(const char *id, ValueType &/*value*/, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
         if (!type_stack_.empty()) {
             return;
         }
         ValueType value;
-        utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_++, value);
+        utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_++, value, attr.size());
         pk_ = value;
     }
-    void on_primary_key(const char *id, std::string &value, size_t size);
     void on_revision(const char * /*id*/, unsigned long long &/*rev*/) { ++column_index_; }
 
     template < class Type >
@@ -48,11 +48,11 @@ public:
     void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &attr) { on_foreign_key<typename Pointer::value_type>(attr.fetch() ); }
 
     template<class ContainerType>
-    void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
+    static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
     template<class ContainerType>
-    void on_has_many_to_many(const char *id, ContainerType &c, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &/*attr*/) {}
+    static void on_has_many_to_many(const char *id, ContainerType &c, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &/*attr*/) {}
     template<class ContainerType>
-    void on_has_many_to_many(const char *id, ContainerType &c, const utils::foreign_attributes &/*attr*/) {}
+    static void on_has_many_to_many(const char *id, ContainerType &c, const utils::foreign_attributes &/*attr*/) {}
 
 private:
     template<class Type>

include/matador/sql/object_parameter_binder.hpp

@@ -7,6 +7,7 @@
 #include "matador/utils/access.hpp"
 #include "matador/utils/field_attributes.hpp"
 #include "matador/utils/foreign_attributes.hpp"
+#include "matador/utils/primary_key_attribute.hpp"
 
 #include <string>
 
@@ -27,30 +28,29 @@ public:
   }
 
   template<typename ValueType>
-  void on_primary_key(const char *id, ValueType &value, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr);
+  void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
-  void on_primary_key(const char *id, std::string &value, size_t size);
+  static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
-  void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
 
   template < class Type >
-  void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
+  static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
   template < class Pointer >
-  void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
+  static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
   template < class Pointer >
-  void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
+  static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
 
   template<class ContainerType>
-  void on_has_many(const char * /*id*/,
+  static void on_has_many(const char * /*id*/,
                           ContainerType &/*c*/,
                           const char * /*join_column*/,
                           const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const char * /*join_column*/,
                                   const char * /*inverse_join_column*/,
                                   const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const utils::foreign_attributes &/*attr*/) {}
 
@@ -74,42 +74,37 @@ public:
   void reset(size_t start_index);
 
   template < class Type >
-  void on_primary_key(const char * /*id*/, Type &val, std::enable_if_t<std::is_integral_v<Type> && !std::is_same_v<bool, Type>>* = nullptr)
+  void on_primary_key(const char * /*id*/, Type &val, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
-  {
+    utils::data_type_traits<Type>::bind_value(*binder_, index_++, val, attr.size());
-    utils::data_type_traits<Type>::bind_value(*binder_, index_++, val);
   }
-  void on_primary_key(const char *id, std::string &, size_t size);
   void on_revision(const char *id, uint64_t &/*rev*/);
 
   template<typename Type>
-  void on_attribute(const char * /*id*/, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes)
+  void on_attribute(const char * /*id*/, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
-  {
     utils::data_type_traits<Type>::bind_value(*binder_, index_++, val);
   }
 
   template<class Type, template < class ... > class Pointer>
-  void on_belongs_to(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes)
+  void on_belongs_to(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {
-  {
     fk_binder_.bind(*x, index_++, *binder_);
   }
   template<class Type, template < class ... > class Pointer>
-  void on_has_one(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes)
+  void on_has_one(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {
-  {
     fk_binder_.bind(*x, index_++, *binder_);
   }
   template<class ContainerType>
-  void on_has_many(const char * /*id*/,
+  static void on_has_many(const char * /*id*/,
                           ContainerType &/*c*/,
                           const char * /*join_column*/,
                           const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const char * /*join_column*/,
                                   const char * /*inverse_join_column*/,
                                   const utils::foreign_attributes &/*attr*/) {}
   template<class ContainerType>
-  void on_has_many_to_many(const char * /*id*/,
+  static void on_has_many_to_many(const char * /*id*/,
                                   ContainerType &/*c*/,
                                   const utils::foreign_attributes &/*attr*/) {}
 
@@ -122,9 +117,8 @@ private:
 namespace detail {
 
 template<typename ValueType>
-void fk_binder::on_primary_key(const char * /*id*/, ValueType &value, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> *)
+void fk_binder::on_primary_key(const char * /*id*/, ValueType &value, const utils::primary_key_attribute& attr) {
-{
+  utils::data_type_traits<ValueType>::bind_value(*binder_, index_++, value, attr.size());
-  utils::data_type_traits<ValueType>::bind_value(*binder_, index_++, value);
 }
 
 }

include/matador/utils/access.hpp

@@ -15,6 +15,7 @@ class container;
 namespace utils {
 class field_attributes;
 class foreign_attributes;
+class primary_key_attribute;
 }
 
 namespace access {
@@ -29,13 +30,13 @@ void process(Operator &op, const Type &object) {
 }
 
 template< class Operator, class Type >
-void primary_key(Operator &op, const char *id, Type &value) {
+void primary_key(Operator &op, const char *id, Type &value, const utils::primary_key_attribute &attr) {
-  op.on_primary_key(id, value);
+  op.on_primary_key(id, value, attr);
 }
 
-template< class Operator >
+template< class Operator, class Type >
-void primary_key(Operator &op, const char *id, std::string &value, size_t size ) {
+void primary_key(Operator &op, const char *id, Type &value) {
-  op.on_primary_key(id, value, size);
+  op.on_primary_key(id, value);
 }
 
 template<class Operator>

include/matador/utils/default_type_traits.hpp

@@ -13,85 +13,85 @@ namespace matador::utils {
 template <> struct data_type_traits<nullptr_t, void>
 {
   static basic_type type(std::size_t /*size*/) { return basic_type::type_null; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, nullptr_t &/*value*/);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, nullptr_t &/*value*/, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, nullptr_t &/*value*/);
+  static void bind_value(attribute_writer &binder, size_t index, nullptr_t &/*value*/, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<int8_t, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int8; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, int8_t &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, int8_t &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const int8_t &value);
+  static void bind_value(attribute_writer &binder, size_t index, const int8_t &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<int16_t, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int16; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, int16_t &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, int16_t &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const int16_t &value);
+  static void bind_value(attribute_writer &binder, size_t index, const int16_t &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<int32_t, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int32; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, int32_t &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, int32_t &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const int32_t &value);
+  static void bind_value(attribute_writer &binder, size_t index, const int32_t &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<int64_t, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int64; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, int64_t &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, int64_t &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const int64_t &value);
+  static void bind_value(attribute_writer &binder, size_t index, const int64_t &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<uint8_t, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_uint8; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, uint8_t &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, uint8_t &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const uint8_t &value);
+  static void bind_value(attribute_writer &binder, size_t index, const uint8_t &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<uint16_t, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_uint16; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, uint16_t &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, uint16_t &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const uint16_t &value);
+  static void bind_value(attribute_writer &binder, size_t index, const uint16_t &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<uint32_t, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_uint32; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, uint32_t &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, uint32_t &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const uint32_t &value);
+  static void bind_value(attribute_writer &binder, size_t index, const uint32_t &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<uint64_t, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_uint64; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, uint64_t &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, uint64_t &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const uint64_t &value);
+  static void bind_value(attribute_writer &binder, size_t index, const uint64_t &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<bool, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_bool; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, bool &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, bool &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const bool &value);
+  static void bind_value(attribute_writer &binder, size_t index, const bool &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<float, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_float; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, float &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, float &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const float &value);
+  static void bind_value(attribute_writer &binder, size_t index, const float &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<double, void>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_double; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, double &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, double &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, const double &value);
+  static void bind_value(attribute_writer &binder, size_t index, const double &value, size_t /*size*/ = 0);
 };
 
 template <> struct data_type_traits<const char*, void>
@@ -131,8 +131,8 @@ template <> struct data_type_traits<std::string, void>
 template <> struct data_type_traits<utils::blob, void>
 {
   static basic_type type(std::size_t /*size*/) { return basic_type::type_blob; }
-  static void read_value(attribute_reader &reader, const char *id, size_t index, utils::blob &value);
+  static void read_value(attribute_reader &reader, const char *id, size_t index, utils::blob &value, size_t /*size*/ = 0);
-  static void bind_value(attribute_writer &binder, size_t index, utils::blob &value);
+  static void bind_value(attribute_writer &binder, size_t index, utils::blob &value, size_t /*size*/ = 0);
 };
 
 //template <> struct data_type_traits<matador::date, void>
@@ -153,13 +153,11 @@ template < typename EnumType >
 struct data_type_traits<EnumType, std::enable_if_t<std::is_enum_v<EnumType>>>
 {
   static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int32; }
-  static void read_value(attribute_reader &reader, const char *id, const size_t index, EnumType &value)
+  static void read_value(attribute_reader &reader, const char *id, const size_t index, EnumType &value, const size_t size = 0) {
-  {
+    data_type_traits<int>::read_value(reader, id, index, reinterpret_cast<int&>(value), size);
-    data_type_traits<int>::read_value(reader, id, index, reinterpret_cast<int&>(value));
   }
-  static void bind_value(attribute_writer &binder, const size_t index, EnumType &value)
+  static void bind_value(attribute_writer &binder, const size_t index, EnumType &value, const size_t size = 0) {
-  {
+    data_type_traits<int>::bind_value(binder, index, static_cast<int &>(value), size);
-    data_type_traits<int>::bind_value(binder, index, static_cast<int &>(value));
   }
 };
 /// @endcond

include/matador/utils/field_attributes.hpp

@@ -9,10 +9,10 @@ namespace matador::utils {
 
 /**
  * This class represents field attributes in
- * form of size and constraints for a database
+ * the form of size and constraints for a database
  * field (column)
  *
- * Currently the size is only applied
+ * Currently, the size is only applied
  * to a field of type string leading
  * to VARCHAR(size).
  */

include/matador/utils/primary_key_attribute.hpp

@@ -1,6 +1,8 @@
 #ifndef PRIMARY_KEY_ATTRIBUTE_HPP
 #define PRIMARY_KEY_ATTRIBUTE_HPP
 
+#include "matador/utils/primary_key_generator_type.hpp"
+
 #include <cstddef>
 
 namespace matador::utils {
@@ -18,6 +20,8 @@ public:
      * @param size Size of the attribute
      */
     primary_key_attribute(size_t size); // NOLINT(*-explicit-constructor)
+    primary_key_attribute(generator_type generator); // NOLINT(*-explicit-constructor)
+    primary_key_attribute(size_t size, generator_type generator);
     ~primary_key_attribute() = default;
     primary_key_attribute(const primary_key_attribute &) = default;
     primary_key_attribute(primary_key_attribute &&) = default;
@@ -25,6 +29,7 @@ public:
     primary_key_attribute &operator=(primary_key_attribute &&) = default;
 
   primary_key_attribute& operator=(size_t size);
+    primary_key_attribute& operator=(generator_type generator);
 
     /**
      * Returns the size of the field
@@ -33,9 +38,18 @@ public:
      */
     [[nodiscard]] size_t size() const;
 
+    /**
+     * Returns the generator type of the field
+     *
+     * @return Generator type of the field
+     */
+    [[nodiscard]] generator_type generator() const;
 private:
     size_t size_ = 0;
+    generator_type generator_ = generator_type::MANUALLY;
 };
 
+const primary_key_attribute default_pk_attributes {};
+
 }
 #endif //PRIMARY_KEY_ATTRIBUTE_HPP

include/matador/utils/primary_key_generator_type.hpp

@@ -0,0 +1,13 @@
+#ifndef PRIMARY_KEY_GENERATOR_TYPE_HPP
+#define PRIMARY_KEY_GENERATOR_TYPE_HPP
+
+namespace matador::utils {
+enum class generator_type {
+  MANUALLY,
+  AUTO,
+  IDENTITY,
+  SEQUENCE,
+  TABLE
+};
+}
+#endif //PRIMARY_KEY_GENERATOR_TYPE_HPP

source/core/CMakeLists.txt

@@ -57,6 +57,7 @@ add_library(matador-core STATIC
   ../../include/matador/utils/os.hpp
   ../../include/matador/utils/placeholder.hpp
   ../../include/matador/utils/primary_key_attribute.hpp
+  ../../include/matador/utils/primary_key_generator_type.hpp
   ../../include/matador/utils/result.hpp
   ../../include/matador/utils/singleton.hpp
   ../../include/matador/utils/string.hpp
@@ -79,7 +80,6 @@ add_library(matador-core STATIC
   object/foreign_node_completer.cpp
   object/internal/shadow_schema.cpp
   object/object_definition.cpp
-  object/primary_key_resolver.cpp
   object/relation_endpoint.cpp
   object/schema.cpp
   object/schema_node.cpp

source/core/object/attribute_definition_generator.cpp

@@ -8,11 +8,6 @@ attribute_definition_generator::attribute_definition_generator(std::vector<objec
 , repo_(repo)
 {}
 
-void attribute_definition_generator::on_primary_key(const char *id, std::string &pk, size_t size)
-{
-    on_attribute(id, pk, { size, utils::constraints::PRIMARY_KEY });
-}
-
 void attribute_definition_generator::on_revision(const char *id, uint64_t &rev)
 {
     on_attribute(id, rev);
@@ -26,9 +21,4 @@ void attribute_definition_generator::insert_missing_reference_column(const std::
   const_cast<schema&>(repo_).missing_references_.insert({ti, ref_column});
 }
 
-void fk_attribute_generator::on_primary_key(const char *, std::string &, const size_t size)
-{
-    type_ = utils::data_type_traits<std::string>::type(size);
-}
-
 }

source/core/object/primary_key_resolver.cpp

@@ -1,10 +0,0 @@
-#include "matador/object/primary_key_resolver.hpp"
-
-namespace matador::object {
-void primary_key_resolver::on_primary_key(const char *id, const std::string &pk, size_t /*size*/) {
-  primary_key_info_.pk_column_name = id;
-  primary_key_info_.type = utils::basic_type::type_varchar;
-  primary_key_info_.pk = pk;
-}
-
-}

source/core/utils/default_type_traits.cpp

@@ -5,159 +5,129 @@
 
 namespace matador::utils {
 
-void data_type_traits<nullptr_t>::read_value(attribute_reader &/*reader*/, const char * /*id*/, size_t /*index*/, nullptr_t &/*value*/)
+void data_type_traits<nullptr_t>::read_value(attribute_reader &/*reader*/, const char * /*id*/, size_t /*index*/, nullptr_t &/*value*/, const size_t /*size*/)
 {}
 
-void data_type_traits<nullptr_t>::bind_value(attribute_writer &/*binder*/, size_t /*index*/, nullptr_t &/*value*/)
+void data_type_traits<nullptr_t>::bind_value(attribute_writer &/*binder*/, size_t /*index*/, nullptr_t &/*value*/, const size_t /*size*/)
 {}
 
-void data_type_traits<int8_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int8_t &value)
+void data_type_traits<int8_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int8_t &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<int8_t>::bind_value(attribute_writer &binder, const size_t index, const int8_t &value)
+void data_type_traits<int8_t>::bind_value(attribute_writer &binder, const size_t index, const int8_t &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<int16_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int16_t &value)
+void data_type_traits<int16_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int16_t &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<int16_t>::bind_value(attribute_writer &binder, const size_t index, const int16_t &value)
+void data_type_traits<int16_t>::bind_value(attribute_writer &binder, const size_t index, const int16_t &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<int32_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int32_t &value)
+void data_type_traits<int32_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int32_t &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<int32_t>::bind_value(attribute_writer &binder, const size_t index, const int32_t &value)
+void data_type_traits<int32_t>::bind_value(attribute_writer &binder, const size_t index, const int32_t &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<int64_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int64_t &value)
+void data_type_traits<int64_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int64_t &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<int64_t>::bind_value(attribute_writer &binder, const size_t index, const int64_t &value)
+void data_type_traits<int64_t>::bind_value(attribute_writer &binder, const size_t index, const int64_t &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<uint8_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint8_t &value)
+void data_type_traits<uint8_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint8_t &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<uint8_t>::bind_value(attribute_writer &binder, const size_t index, const uint8_t &value)
+void data_type_traits<uint8_t>::bind_value(attribute_writer &binder, const size_t index, const uint8_t &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<uint16_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint16_t &value)
+void data_type_traits<uint16_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint16_t &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<uint16_t>::bind_value(attribute_writer &binder, const size_t index, const uint16_t &value)
+void data_type_traits<uint16_t>::bind_value(attribute_writer &binder, const size_t index, const uint16_t &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<uint32_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint32_t &value)
+void data_type_traits<uint32_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint32_t &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<uint32_t>::bind_value(attribute_writer &binder, const size_t index, const uint32_t &value)
+void data_type_traits<uint32_t>::bind_value(attribute_writer &binder, const size_t index, const uint32_t &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<uint64_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint64_t &value)
+void data_type_traits<uint64_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint64_t &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<uint64_t>::bind_value(attribute_writer &binder, const size_t index, const uint64_t &value)
+void data_type_traits<uint64_t>::bind_value(attribute_writer &binder, const size_t index, const uint64_t &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<bool>::read_value(attribute_reader &reader, const char *id, const size_t index, bool &value)
+void data_type_traits<bool>::read_value(attribute_reader &reader, const char *id, const size_t index, bool &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<bool>::bind_value(attribute_writer &binder, const size_t index, const bool &value)
+void data_type_traits<bool>::bind_value(attribute_writer &binder, const size_t index, const bool &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<float>::read_value(attribute_reader &reader, const char *id, const size_t index, float &value)
+void data_type_traits<float>::read_value(attribute_reader &reader, const char *id, const size_t index, float &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<float>::bind_value(attribute_writer &binder, const size_t index, const float &value)
+void data_type_traits<float>::bind_value(attribute_writer &binder, const size_t index, const float &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<double>::read_value(attribute_reader &reader, const char *id, const size_t index, double &value)
+void data_type_traits<double>::read_value(attribute_reader &reader, const char *id, const size_t index, double &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<double>::bind_value(attribute_writer &binder, const size_t index, const double &value)
+void data_type_traits<double>::bind_value(attribute_writer &binder, const size_t index, const double &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 
-void data_type_traits<const char*>::read_value(attribute_reader &reader, const char *id, const size_t index, const char* value, const size_t size)
+void data_type_traits<const char*>::read_value(attribute_reader &reader, const char *id, const size_t index, const char* value, const size_t size) {
-{
   reader.read_value(id, index, const_cast<char*>(value), size);
 }
 
-void data_type_traits<const char *>::bind_value(attribute_writer &binder, const size_t index, const char *value, const size_t size)
+void data_type_traits<const char *>::bind_value(attribute_writer &binder, const size_t index, const char *value, const size_t size) {
-{
   binder.write_value(index, value, size);
 }
 
-void data_type_traits<char*>::read_value(attribute_reader &reader, const char *id, const size_t index, char* value, const size_t size)
+void data_type_traits<char*>::read_value(attribute_reader &reader, const char *id, const size_t index, char* value, const size_t size) {
-{
   reader.read_value(id, index, value, size);
 }
 
-void data_type_traits<char *>::bind_value(attribute_writer &binder, const size_t index, const char *value, const size_t size)
+void data_type_traits<char *>::bind_value(attribute_writer &binder, const size_t index, const char *value, const size_t size) {
-{
   binder.write_value(index, value, size);
 }
 
-void data_type_traits<std::string>::read_value(attribute_reader &reader, const char *id, size_t index, std::string &value, size_t size)
+void data_type_traits<std::string>::read_value(attribute_reader &reader, const char *id, const size_t index, std::string &value, const size_t size) {
-{
   reader.read_value(id, index, value, size);
 }
 
-void data_type_traits<std::string>::bind_value(attribute_writer &binder, size_t index, std::string &value, size_t size)
+void data_type_traits<std::string>::bind_value(attribute_writer &binder, const size_t index, std::string &value, const size_t size) {
-{
   binder.write_value(index, value, size);
 }
 
-void data_type_traits<utils::blob, void>::read_value(attribute_reader &reader, const char *id, size_t index, utils::blob &value)
+void data_type_traits<blob>::read_value(attribute_reader &reader, const char *id, const size_t index, utils::blob &value, const size_t /*size*/) {
-{
   reader.read_value(id, index, value);
 }
 
-void data_type_traits<utils::blob, void>::bind_value(attribute_writer &binder, size_t index, utils::blob &value)
+void data_type_traits<blob>::bind_value(attribute_writer &binder, const size_t index, utils::blob &value, const size_t /*size*/) {
-{
   binder.write_value(index, value);
 }
 

source/core/utils/primary_key_attribute.cpp

@@ -2,14 +2,31 @@
 
 namespace matador::utils {
 primary_key_attribute::primary_key_attribute(const size_t size)
-: size_(size) {}
+: size_( size ) {}
+
+primary_key_attribute::primary_key_attribute(const generator_type generator)
+: generator_( generator ) {}
+
+primary_key_attribute::primary_key_attribute(const size_t size, const generator_type generator)
+: size_( size )
+, generator_( generator ) {}
 
 primary_key_attribute& primary_key_attribute::operator=(const size_t size) {
   size_ = size;
   return *this;
 }
 
+primary_key_attribute& primary_key_attribute::operator=(const generator_type generator) {
+  generator_ = generator;
+  return *this;
+}
+
 size_t primary_key_attribute::size() const {
   return size_;
 }
+
+generator_type primary_key_attribute::generator() const {
+  return generator_;
+}
+
 }

source/orm/CMakeLists.txt

@@ -71,7 +71,6 @@ add_library(matador-orm STATIC
   query/attribute_string_writer.cpp
   query/basic_condition.cpp
   query/condition.cpp
-  query/fk_value_extractor.cpp
   query/intermediates/executable_query.cpp
   query/intermediates/fetchable_query.cpp
   query/intermediates/query_create_intermediate.cpp

source/orm/orm/session_insert_builder.cpp

@@ -1,10 +1,6 @@
 #include "matador/orm/session_insert_builder.hpp"
 
 namespace matador::orm {
-void session_insert_builder::on_primary_key(const char* id, std::string& value, size_t) {
-    push(id, value);
-}
-
 void session_insert_builder::on_revision(const char* id, unsigned long long& x) {
     push(id, x);
 }

source/orm/orm/session_query_builder.cpp

@@ -3,14 +3,6 @@
 #include <iostream>
 
 namespace matador::orm {
-void session_query_builder::on_primary_key(const char *id, std::string &, size_t) {
-  push(id);
-  if (!is_root_entity()) {
-    const auto b = pk_.is_varchar();
-    std::cout << "is matching primary key: " << std::boolalpha << b << "\n";
-  }
-}
-
 void session_query_builder::on_revision(const char *id, unsigned long long &/*rev*/) {
   push(id);
 }

source/orm/query/fk_value_extractor.cpp

@@ -1,10 +0,0 @@
-#include "matador/query/fk_value_extractor.hpp"
-
-namespace matador::query::detail {
-
-void fk_value_extractor::on_primary_key(const char *, std::string &pk, size_t)
-{
-  value_ = pk;
-}
-
-}

source/orm/query/internal/query_result_impl.cpp

@@ -7,11 +7,6 @@ namespace matador::sql {
 detail::pk_reader::pk_reader(query_result_reader &reader)
 : reader_(reader) {}
 
-void detail::pk_reader::on_primary_key(const char *id, std::string &value, size_t size)
-{
-  utils::data_type_traits<std::string>::read_value(reader_, id, column_index_++, value, size);
-}
-
 query_result_impl::query_result_impl(std::unique_ptr<query_result_reader> &&reader, std::vector<object::attribute_definition> &&prototype, const size_t column_index)
 : column_index_(column_index)
 , prototype_(std::move(prototype))
@@ -26,11 +21,6 @@ query_result_impl::query_result_impl(std::unique_ptr<query_result_reader> &&read
 , pk_reader_(*reader_)
 {}
 
-void query_result_impl::on_primary_key(const char *id, std::string &value, size_t size)
-{
-  utils::data_type_traits<std::string>::read_value(*reader_, id, column_index_++, value, size);
-}
-
 void query_result_impl::on_revision(const char *id, uint64_t &rev)
 {
   utils::data_type_traits<uint64_t>::read_value(*reader_, id, column_index_++, rev);

source/orm/query/key_value_generator.cpp

@@ -4,13 +4,7 @@
 
 namespace matador::query {
 
-void key_value_generator::on_primary_key(const char *id, std::string &x, size_t)
+void key_value_generator::on_revision(const char *id, unsigned long long int &x) {
-{
-  result_.emplace_back(id, x);
-}
-
-void key_value_generator::on_revision(const char *id, unsigned long long int &x)
-{
   result_.emplace_back(id, x);
 }
 

source/orm/query/query_compiler.cpp

@@ -275,8 +275,8 @@ void query_compiler::visit(internal::query_create_table_part &create_table_part)
   }
   for (const auto &[column, reference_column]: context.foreign_contexts) {
     // ALTER TABLE Orders ADD CONSTRAINT FK_PersonOrder FOREIGN KEY (PersonID) REFERENCES Persons(PersonID);
-    std::string fk_cmd = "ALTER TABLE " + query_.table.name + " ADD";
+    std::string fk_cmd = "ALTER TABLE " + dialect_->prepare_identifier_string(query_.table.name) + " ADD";
-    fk_cmd += " CONSTRAINT FK_" + create_table_part.table().name;
+    fk_cmd += " CONSTRAINT FK_" + query_.table.name;
     fk_cmd += "_" + column;
     fk_cmd += " FOREIGN KEY (" + dialect_->prepare_identifier_string(column) + ")";
     fk_cmd += " REFERENCES " + reference_column->table_name() + "(" + reference_column->name() + ")";

source/orm/query/value_extractor.cpp

@@ -6,11 +6,6 @@ value_extractor::value_extractor(std::vector<utils::database_type> &values)
 : values_(values)
 {}
 
-void value_extractor::on_primary_key(const char *, std::string &pk, size_t s)
-{
-  utils::data_type_traits<std::string>::bind_value(*this, 0, pk, s);
-}
-
 void value_extractor::on_revision(const char *, uint64_t &rev)
 {
   utils::data_type_traits<uint64_t>::bind_value(*this, 0, rev);

source/orm/sql/column_generator.cpp

@@ -18,14 +18,6 @@ column_generator::column_generator(std::vector<column> &column_infos,
     seen_tables.insert(table_name);
 }
 
-void column_generator::on_primary_key(const char *id, std::string &, size_t)
-{
-    if (has_many_to_many_) {
-        return;
-    }
-    push(id);
-}
-
 void column_generator::on_revision(const char *id, unsigned long long int &)
 {
     if (has_many_to_many_) {

source/orm/sql/internal/object_result_binder.cpp

@@ -4,25 +4,11 @@
 
 namespace matador::sql {
 
-namespace detail {
-
-void fk_result_binder::on_primary_key(const char * /*id*/, std::string &value, const size_t size)
-{
-  utils::data_type_traits<std::string>::read_value(*binder_, id_, index_++, value, size);
-}
-
-}
-
 void object_result_binder::reset()
 {
   index_ = 0;
 }
 
-void object_result_binder::on_primary_key(const char *id, std::string &value, const size_t size)
-{
-  utils::data_type_traits<std::string>::read_value(*binder_, id, index_++, value, size);
-}
-
 void object_result_binder::on_revision(const char *id, uint64_t &value)
 {
   utils::data_type_traits<uint64_t>::read_value(*binder_, id, index_++, value);

source/orm/sql/internal/query_result_pk_resolver.cpp

@@ -3,15 +3,6 @@
 #include "matador/utils/value.hpp"
 
 namespace matador::sql::internal {
-void query_result_pk_resolver::on_primary_key(const char* id, std::string& /*value*/, const size_t size) {
-    if (!type_stack_.empty()) {
-        return;
-    }
-    std::string value;
-    utils::data_type_traits<std::string>::read_value(reader_, id, column_index_++, value, size);
-    pk_ = value;
-}
-
 void query_result_pk_resolver::on_attribute(const char *id, const utils::value &x, const utils::field_attributes &attr) {
     if (is_constraint_set(attr.options(), utils::constraints::PRIMARY_KEY)) {
         if (x.is_integer()) {

source/orm/sql/object_parameter_binder.cpp

@@ -3,25 +3,11 @@
 
 namespace matador::sql {
 
-namespace detail {
-
-void fk_binder::on_primary_key(const char * /*id*/, std::string &value, size_t /*size*/)
-{
-  utils::data_type_traits<std::string>::bind_value(*binder_, index_++, value);
-}
-
-}
-
 void object_parameter_binder::reset(const size_t start_index)
 {
   index_ = start_index;
 }
 
-void object_parameter_binder::on_primary_key(const char * /*id*/, std::string &val, const size_t size)
-{
-  utils::data_type_traits<std::string>::bind_value(*binder_, index_++, val, size);
-}
-
 void object_parameter_binder::on_revision(const char * /*id*/, uint64_t &rev)
 {
   utils::data_type_traits<uint64_t>::bind_value(*binder_, index_++, rev);

test/orm/query/QueryBuilderTest.cpp

@@ -12,9 +12,6 @@
 
 #include "matador/utils/placeholder.hpp"
 
-// #include "models/author.hpp"
-// #include "models/book.hpp"
-
 using namespace matador::test;
 using namespace matador::object;
 using namespace matador::sql;
@@ -31,15 +28,17 @@ TEST_CASE_METHOD(QueryFixture, "Test create table sql statement string", "[query
 
   REQUIRE(result == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##");
 
-  result = query::create()
+  auto ctx = query::create()
     .table("person", {
       make_pk_column<uint32_t>("id"),
       make_column<std::string>("name", {255, constraints::UNIQUE}, null_option::NOT_NULL),
       make_column<unsigned short>("age"),
       make_fk_column<uint32_t>("address", "address", "id")
-    }).str(*db);
+    }).compile(*db);
 
-  REQUIRE(result == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL UNIQUE, "age" INTEGER NOT NULL, "address" BIGINT NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id), CONSTRAINT FK_person_address FOREIGN KEY (address) REFERENCES address(id)))##");
+  REQUIRE(ctx.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL UNIQUE, "age" INTEGER NOT NULL, "address" BIGINT NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##");
+  REQUIRE(ctx.additional_commands.size() == 1);
+  REQUIRE(ctx.additional_commands[0].sql == R"##(ALTER TABLE "person" ADD CONSTRAINT FK_person_address FOREIGN KEY ("address") REFERENCES address(id))##");
 }
 
 TEST_CASE_METHOD(QueryFixture, "Test drop table sql statement string", "[query]") {