renamed constraint to restriction

source/core/CMakeLists.txt

@@ -16,13 +16,13 @@ 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/constraints_generator.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.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
@@ -32,6 +32,7 @@ add_library(matador-core STATIC
   ../../include/matador/object/repository.hpp
   ../../include/matador/object/repository_node.hpp
   ../../include/matador/object/repository_node_iterator.hpp
+  ../../include/matador/object/restriction.hpp
   ../../include/matador/sql/statement_cache.hpp
   ../../include/matador/utils/access.hpp
   ../../include/matador/utils/attribute_reader.hpp
@@ -80,15 +81,17 @@ add_library(matador-core STATIC
   object/attribute.cpp
   object/attribute_generator.cpp
   object/basic_object_info.cpp
-  object/constraint.cpp
   object/constraints_generator.cpp
   object/error_code.cpp
   object/foreign_node_completer.cpp
   object/internal/shadow_repository.cpp
+  object/object.cpp
+  object/object_generator.cpp
   object/relation_endpoint.cpp
   object/repository.cpp
   object/repository_node.cpp
   object/repository_node_iterator.cpp
+  object/restriction.cpp
   utils/default_type_traits.cpp
   utils/error.cpp
   utils/errors.cpp
@@ -107,9 +110,6 @@ add_library(matador-core STATIC
   utils/uuid.cpp
   utils/value.cpp
   utils/version.cpp
-  object/object.cpp
-  ../../include/matador/object/object_generator.hpp
-  object/object_generator.cpp
 )
 
 target_link_libraries(matador-core ${CMAKE_DL_LIBS})

source/core/object/basic_object_info.cpp

@@ -25,7 +25,7 @@ const std::list<attribute>& basic_object_info::attributes() const {
   return object_->attributes();
 }
 
-const std::list<class constraint>& basic_object_info::constraints() const {
+const std::list<class restriction>& basic_object_info::constraints() const {
   return object_->constraints();
 }
 

source/core/object/constraints_generator.cpp

@@ -5,13 +5,13 @@
 #include <algorithm>
 
 namespace matador::object {
-constraints_generator::constraints_generator(std::list<class constraint> &constraints, const repository& repo, const std::shared_ptr<object> &obj)
+constraints_generator::constraints_generator(std::list<class restriction> &constraints, const repository& repo, const std::shared_ptr<object> &obj)
 : constraints_(constraints)
 , repo_(repo)
 , obj_(obj) {}
 
 void constraints_generator::create_pk_constraint(const std::string& name) const {
-  class constraint pk_constraint("PK_" + obj_->name());
+  class restriction pk_constraint("PK_" + obj_->name());
   pk_constraint.options_ |= utils::constraints::PrimaryKey;
   if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(obj_->attributes_)) {
       pk_constraint.attr_ = &*pk_attr;
@@ -26,7 +26,7 @@ void constraints_generator::create_fk_constraint(const std::type_index& ti, cons
     return;
   }
   const auto *pk_attribute = result.value().get().primary_key_attribute();
-  class constraint pk_constraint("FK_" + obj_->name() + "_" + name);
+  class restriction pk_constraint("FK_" + obj_->name() + "_" + name);
   pk_constraint.options_ |= utils::constraints::ForeignKey;
   if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(obj_->attributes_)) {
     pk_constraint.attr_ = &*pk_attr;
@@ -38,7 +38,7 @@ void constraints_generator::create_fk_constraint(const std::type_index& ti, cons
 }
 
 void constraints_generator::create_unique_constraint(const std::string& name) const {
-  class constraint pk_constraint("UK_" + obj_->name() + "_" + name);
+  class restriction pk_constraint("UK_" + obj_->name() + "_" + name);
   pk_constraint.options_ |= utils::constraints::Unique;
   if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(obj_->attributes_)) {
     pk_constraint.attr_ = &*pk_attr;

source/core/object/object.cpp

@@ -72,7 +72,7 @@ size_t object::constraint_count() const {
   return constraints_.size();
 }
 
-const std::list<class constraint>& object::constraints() const {
+const std::list<class restriction>& object::constraints() const {
   return constraints_;
 }
 

source/core/object/object_generator.cpp

@@ -14,7 +14,7 @@ void object_generator::on_revision(const char* id, uint64_t& rev) {
 }
 
 void object_generator::create_pk_constraint(const std::string& name) const {
-    class constraint pk_constraint("PK_" + object_->name());
+    class restriction pk_constraint("PK_" + object_->name());
     pk_constraint.options_ |= utils::constraints::PrimaryKey;
     if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) {
         pk_constraint.attr_ = &*pk_attr;
@@ -26,7 +26,7 @@ void object_generator::create_pk_constraint(const std::string& name) const {
 void object_generator::create_fk_constraint(const std::type_index& ti, const std::string& name) const {
     const auto obj = fk_object(ti);
     const auto *pk_attribute = obj->primary_key_attribute();
-    class constraint pk_constraint("FK_" + object_->name() + "_" + name);
+    class restriction pk_constraint("FK_" + object_->name() + "_" + name);
     pk_constraint.options_ |= utils::constraints::ForeignKey;
     if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) {
         pk_constraint.attr_ = &*pk_attr;
@@ -41,7 +41,7 @@ void object_generator::create_fk_constraint(const std::type_index& ti, const std
 }
 
 void object_generator::create_unique_constraint(const std::string& name) const {
-    class constraint pk_constraint("UK_" + object_->name() + "_" + name);
+    class restriction pk_constraint("UK_" + object_->name() + "_" + name);
     pk_constraint.options_ |= utils::constraints::Unique;
     if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) {
         pk_constraint.attr_ = &*pk_attr;

source/core/object/restriction.cpp

@@ -1,15 +1,16 @@
-#include "matador/object/constraint.hpp"
+#include "matador/object/restriction.hpp"
+
 #include "matador/object/attribute.hpp"
 
 namespace matador::object {
-constraint::constraint(std::string name)
+restriction::restriction(std::string name)
 : name_(std::move(name)) {}
 
-const std::string & constraint::name() const {
+const std::string & restriction::name() const {
   return name_;
 }
 
-const class attribute* constraint::attribute() const {
+const class attribute* restriction::attribute() const {
   if (std::holds_alternative<class attribute*>(attr_)) {
     return std::get<class attribute*>(attr_);
   }
@@ -17,7 +18,7 @@ const class attribute* constraint::attribute() const {
   return nullptr;
 }
 
-std::string constraint::column_name() const {
+std::string restriction::column_name() const {
     if (std::holds_alternative<class attribute*>(attr_)) {
         return std::get<class attribute*>(attr_)->name();
     }
@@ -28,31 +29,31 @@ std::string constraint::column_name() const {
     return "";
 }
 
-std::shared_ptr<object> constraint::owner() const {
+std::shared_ptr<object> restriction::owner() const {
   return owner_;
 }
 
-bool constraint::is_primary_key_constraint() const {
+bool restriction::is_primary_key_constraint() const {
   return utils::is_constraint_set(options_, utils::constraints::PrimaryKey);
 }
 
-bool constraint::is_foreign_key_constraint() const {
+bool restriction::is_foreign_key_constraint() const {
   return utils::is_constraint_set(options_, utils::constraints::ForeignKey);
 }
 
-bool constraint::is_unique_constraint() const {
+bool restriction::is_unique_constraint() const {
   return utils::is_constraint_set(options_, utils::constraints::Unique);
 }
 
-const std::string& constraint::ref_table_name() const {
+const std::string& restriction::ref_table_name() const {
   return ref_table_name_;
 }
 
-const std::string& constraint::ref_column_name() const {
+const std::string& restriction::ref_column_name() const {
   return ref_column_name_;
 }
 
-std::ostream & operator<<(std::ostream &os, const class constraint &c) {
+std::ostream & operator<<(std::ostream &os, const class restriction &c) {
   os << "constraint " << c.name_ << " for column " << c.column_name();
   return os;
 }
@@ -81,8 +82,8 @@ constraint_builder & constraint_builder::references(std::string table, std::stri
   return *this;
 }
 
-constraint_builder::operator class constraint() const {
-  class constraint c;
+constraint_builder::operator class restriction() const {
+  class restriction c;
   c.name_ = constraint_name;
   c.attr_ = column_name;
   c.options_ = options_;

source/orm/orm/schema.cpp

@@ -181,7 +181,7 @@ utils::result<bool, utils::error> schema::table_exists(const std::string& table_
     return c->exists(repo_.name(), table_name);
 }
 
-sql::query_context schema::build_add_constraint_context( const object::repository_node& node, const class object::constraint& cons ) const {
+sql::query_context schema::build_add_constraint_context( const object::repository_node& node, const class object::restriction& cons ) const {
   if (cons.is_foreign_key_constraint()) {
     return query::query::alter()
       .table(node.name())
@@ -200,7 +200,7 @@ sql::query_context schema::build_add_constraint_context( const object::repositor
   return {};
 }
 
-sql::query_context schema::build_drop_constraint_context( const object::repository_node& node, const class object::constraint& cons ) const {
+sql::query_context schema::build_drop_constraint_context( const object::repository_node& node, const class object::restriction& cons ) const {
     return query::query::alter()
       .table(node.name())
       .drop_constraint(cons.name())

source/orm/orm/session.cpp

@@ -76,7 +76,7 @@ utils::result<void, utils::error> session::create_schema() const {
   return utils::ok<void>();
 }
 
-sql::query_context session::build_add_constraint_context(const std::string& table_name, const class object::constraint& cons, const sql::connection_ptr &conn) {
+sql::query_context session::build_add_constraint_context(const std::string& table_name, const class object::restriction& cons, const sql::connection_ptr &conn) {
   if (cons.is_foreign_key_constraint()) {
     return query::query::alter()
       .table(table_name)

source/orm/query/builder.cpp

@@ -48,8 +48,8 @@ constraint_builder& constraint_builder::references( std::string table, std::stri
   return *this;
 }
 
-constraint_builder::operator object::constraint() const {
-  return object::constraint{constraint_name};
+constraint_builder::operator object::restriction() const {
+  return object::restriction{constraint_name};
 }
 
 constraint_builder constraint( std::string name ) {

source/orm/query/intermediates/query_create_intermediate.cpp

@@ -18,27 +18,31 @@ executable_query query_create_intermediate::schema( const std::string& schema_na
   return {context_};
 }
 
-executable_query query_create_table_columns_intermediate::constraints( std::initializer_list<class object::constraint> constraints ) {
+executable_query query_create_table_columns_intermediate::constraints(const std::initializer_list<class object::restriction> constraints) {
   return this->constraints(std::list(constraints));
 }
 
-executable_query query_create_table_columns_intermediate::constraints( const std::list<class object::constraint>& constraints ) {
+executable_query query_create_table_columns_intermediate::constraints(const std::list<class object::restriction>& constraints) {
 
   context_->parts.push_back(std::make_unique<internal::query_create_table_constraints_part>(constraints));
   return {context_};
 }
 
-query_create_table_columns_intermediate query_create_table_intermediate::columns( std::initializer_list<object::attribute> columns ) {
+query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list<object::attribute> columns) {
   context_->parts.push_back(std::make_unique<internal::query_create_table_columns_part>(columns));
   return {context_};
 }
 
-query_create_table_columns_intermediate query_create_table_intermediate::columns( const std::list<object::attribute>& columns ) {
+query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list<object::attribute>& columns) {
   context_->parts.push_back(std::make_unique<internal::query_create_table_columns_part>(columns));
   return {context_};
 }
 
-query_create_table_columns_intermediate query_create_table_intermediate::columns( std::initializer_list<column> columns ) {}
+query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list<column> columns) {
+  return {context_};
+}
 
-query_create_table_columns_intermediate query_create_table_intermediate::columns( const std::list<column>& columns ) {}
+query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list<column>& columns) {
+  return {context_};
+}
 }

source/orm/query/internal/query_parts.cpp

@@ -370,11 +370,11 @@ void query_create_table_columns_part::accept(query_part_visitor& visitor) {
   visitor.visit(*this);
 }
 
-query_create_table_constraints_part::query_create_table_constraints_part(const std::list<class object::constraint>& constraints)
+query_create_table_constraints_part::query_create_table_constraints_part(const std::list<class object::restriction>& constraints)
 : query_part( sql::dialect_token::Constraint )
 , constraints_(constraints) {}
 
-const std::list<class object::constraint>& query_create_table_constraints_part::constraints() const {
+const std::list<class object::restriction>& query_create_table_constraints_part::constraints() const {
   return constraints_;
 }
 

source/orm/query/query_compiler.cpp

@@ -294,7 +294,7 @@ void query_compiler::visit(internal::query_create_part &/*create_part*/)
 }
 
 std::string build_create_column(const object::attribute &col, const sql::dialect &d);
-std::string build_constraint(const class object::constraint &cons, const sql::dialect &d);
+std::string build_constraint(const class object::restriction &cons, const sql::dialect &d);
 
 void query_compiler::visit(internal::query_create_table_part &part)
 {
@@ -392,7 +392,7 @@ std::string build_create_column(const object::attribute &col, const sql::dialect
   return result;
 }
 
-std::string build_constraint(const class object::constraint& cons, const sql::dialect& d) {
+std::string build_constraint(const class object::restriction& cons, const sql::dialect& d) {
     std::string result;
     if (!cons.name().empty()) {
         result.append(d.constraint()).append(" ").append(cons.name()).append(" ");