preparations for object_generator (generating objects with attributes and constraints)

source/core/CMakeLists.txt

@@ -16,10 +16,12 @@ add_library(matador-core STATIC
   ../../include/matador/object/attribute.hpp
   ../../include/matador/object/attribute_generator.hpp
   ../../include/matador/object/basic_object_info.hpp
+  ../../include/matador/object/constraint.hpp
   ../../include/matador/object/error_code.hpp
   ../../include/matador/object/foreign_node_completer.hpp
   ../../include/matador/object/internal/shadow_repository.hpp
   ../../include/matador/object/many_to_many_relation.hpp
+  ../../include/matador/object/object_generator.hpp
   ../../include/matador/object/object_info.hpp
   ../../include/matador/object/object_proxy.hpp
   ../../include/matador/object/object_ptr.hpp
@@ -77,6 +79,7 @@ add_library(matador-core STATIC
   object/attribute.cpp
   object/attribute_generator.cpp
   object/basic_object_info.cpp
+  object/constraint.cpp
   object/error_code.cpp
   object/foreign_node_completer.cpp
   object/internal/shadow_repository.cpp

source/core/object/attribute.cpp

@@ -147,14 +147,14 @@ attribute make_column<std::string>(const std::string &name, utils::field_attribu
 
 template<>
 attribute make_pk_column<std::string>(const std::string &name, size_t size) {
-  return make_column<std::string>(name, {size, utils::constraints::PRIMARY_KEY});
+  return make_column<std::string>(name, {size, utils::constraints::PrimaryKey});
 }
 
 template<>
 attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column) {
   return {
     name, utils::data_type_traits<std::string>::type(size), 0, ref_column,
-    {size, utils::constraints::FOREIGN_KEY}, null_option_type::NOT_NULL
+    {size, utils::constraints::ForeignKey}, null_option_type::NOT_NULL
   };
 }
 
@@ -162,17 +162,17 @@ template<>
 attribute make_fk_column<std::string>( const std::string& name, const std::string& ref_table_name, const std::string& ref_column_name ) {
     return {
             name, utils::basic_type::type_varchar, 0,
-            std::make_shared<attribute>(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::FOREIGN_KEY}),
-            { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL
+            std::make_shared<attribute>(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::ForeignKey}),
+            { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL
     };
 }
 
 template<>
 attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name) {
-  const auto ref_column = std::make_shared<attribute>(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::FOREIGN_KEY});
+  const auto ref_column = std::make_shared<attribute>(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::ForeignKey});
   return {
     name, utils::data_type_traits<std::string>::type(size), 0, ref_column,
-    {size, utils::constraints::FOREIGN_KEY}, null_option_type::NOT_NULL
+    {size, utils::constraints::ForeignKey}, null_option_type::NOT_NULL
   };
 }
 }

source/core/object/constraint.cpp

@@ -0,0 +1,48 @@
+#include "matador/object/constraint.hpp"
+
+namespace matador::object {
+constraint::constraint(std::string name)
+: name_(std::move(name)) {}
+
+const std::string & constraint::name() const {
+  return name_;
+}
+
+constraint_builder & constraint_builder::constraint(std::string name) {
+  constraint_name = std::move(name);
+  return *this;
+}
+
+constraint_builder & constraint_builder::primary_key(std::string name) {
+  column_name = std::move(name);
+  options_ |= utils::constraints::PrimaryKey;
+  return *this;
+}
+
+constraint_builder & constraint_builder::foreign_key(std::string name) {
+  column_name = std::move(name);
+  options_ |= utils::constraints::ForeignKey;
+  return *this;
+}
+
+constraint_builder & constraint_builder::references(std::string table, std::string column) {
+  ref_table_name = std::move(table);
+  ref_column_name = std::move(column);
+
+  return *this;
+}
+
+constraint_builder::operator class constraint() const {
+  class constraint c;
+  c.name_ = constraint_name;
+  c.options_ = options_;
+  c.ref_column_name_ = ref_column_name;
+  c.ref_table_name_ = ref_table_name;
+  return {};
+}
+
+constraint_builder constraint(std::string name) {
+  constraint_builder builder;
+  return builder.constraint(std::move(name));
+}
+}

source/core/object/repository_node.cpp

@@ -110,7 +110,7 @@ std::shared_ptr<attribute> repository_node::determine_reference_column(const std
                                                                                   repository& repo) {
     const auto it = repo.missing_references_.find(ti);
     if (it == repo.missing_references_.end()) {
-        return std::make_shared<attribute>(pk_info.pk_column_name, pk_info.type, table_name, attribute_options{utils::constraints::FOREIGN_KEY});
+        return std::make_shared<attribute>(pk_info.pk_column_name, pk_info.type, table_name, attribute_options{utils::constraints::ForeignKey});
     }
 
     auto ref_column = it->second;
@@ -118,7 +118,7 @@ std::shared_ptr<attribute> repository_node::determine_reference_column(const std
     ref_column->name(pk_info.pk_column_name);
     ref_column->table_name(table_name);
     ref_column->change_type(pk_info.type);
-    ref_column->attributes() = utils::constraints::FOREIGN_KEY;
+    ref_column->attributes() = utils::constraints::ForeignKey;
 
     if (table_name.empty()) {
       repo.missing_references_.insert({ti, ref_column});

source/core/utils/field_attributes.cpp

@@ -16,7 +16,7 @@ field_attributes::field_attributes(const size_t size, const constraints options)
 
 field_attributes& field_attributes::operator=(const size_t size) {
   size_ = size;
-  options_ = constraints::NONE;
+  options_ = constraints::None;
   return *this;
 }
 field_attributes& field_attributes::operator=(constraints opt) {

source/orm/query/query_compiler.cpp

@@ -396,13 +396,13 @@ std::string build_create_column(const object::attribute &col, const sql::dialect
   if (!col.is_nullable()) {
     result.append(" NOT NULL");
   }
-  if (is_constraint_set(col.attributes().options(), utils::constraints::UNIQUE)) {
+  if (is_constraint_set(col.attributes().options(), utils::constraints::Unique)) {
     result.append(" UNIQUE");
   }
-  if (is_constraint_set(col.attributes().options(), utils::constraints::PRIMARY_KEY)) {
+  if (is_constraint_set(col.attributes().options(), utils::constraints::PrimaryKey)) {
     context.primary_keys.emplace_back(col.name());
   }
-  if (is_constraint_set(col.attributes().options(), utils::constraints::FOREIGN_KEY)) {
+  if (is_constraint_set(col.attributes().options(), utils::constraints::ForeignKey)) {
     context.foreign_contexts.push_back({col.name(), col.reference_column()});
   }
 

source/orm/sql/field.cpp

@@ -101,11 +101,11 @@ bool field::is_null() const
 }
 
 bool field::is_primary_key() const {
-  return type_ == utils::constraints::PRIMARY_KEY;
+  return type_ == utils::constraints::PrimaryKey;
 }
 
 bool field::is_foreign_key() const {
-  return type_ == utils::constraints::FOREIGN_KEY;
+  return type_ == utils::constraints::ForeignKey;
 }
 
 bool field::is_attribute() const {

source/orm/sql/internal/query_result_pk_resolver.cpp

@@ -4,7 +4,7 @@
 
 namespace matador::sql::internal {
 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 (is_constraint_set(attr.options(), utils::constraints::PrimaryKey)) {
         if (x.is_integer()) {
             uint64_t val;
             utils::data_type_traits<uint64_t>::read_value(reader_, id, column_index_++, val);