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

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;
+  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_;
+  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)
-{
-  result_.emplace_back(id, x);
-}
-
-void key_value_generator::on_revision(const char *id, unsigned long long int &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";
-    fk_cmd += " CONSTRAINT FK_" + create_table_part.table().name;
+    std::string fk_cmd = "ALTER TABLE " + dialect_->prepare_identifier_string(query_.table.name) + " ADD";
+    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);