include/matador/object/foreign_node_completer.hpp

@@ -27,9 +27,9 @@ private:
   using node_ptr = std::shared_ptr<repository_node>;
 
 public:
+  template<class Type>
   static void complete(const std::shared_ptr<repository_node> &node) {
-    internal::shadow_repository shadow(node->repo_);
-    foreign_node_completer completer(shadow);
+    foreign_node_completer<Type> completer(internal::shadow_repository(node->repo_));
 
     completer.complete_node(node);
   }
@@ -88,7 +88,7 @@ private:
     }
     const auto node = repository_node::make_node<Type>(repo_.repo(), name);
     if (auto result = repo_.attach_node(node)) {
-      foreign_node_completer<Type>::complete(result.value());
+      complete<Type>(result.value());
     }
   }
 
@@ -100,7 +100,7 @@ private:
 
     const auto node = repository_node::make_node<Type>(repo_.repo(), "");
     if (auto result = repo_.attach_node(node)) {
-      foreign_node_completer<Type>::complete(result.value());
+      complete<Type>(result.value());
     }
   }
 
@@ -133,7 +133,7 @@ private:
       return;
     }
 
-    foreign_node_completer<relation_value_type>::complete(result.value());
+    complete<relation_value_type>(result.value());
 
     // auto& node = result.value();
     const auto local_endpoint = std::make_shared<relation_endpoint>(name, relation_type::HasMany, node);

include/matador/object/relation_completer.hpp

@@ -371,7 +371,7 @@ void relation_completer<Type>::attach_relation_node(const std::string &name, con
     return;
   }
 
-  foreign_node_completer<relation_value_type>::complete(result.value());
+  foreign_node_completer<Type>::template complete<relation_value_type>(result.value());
 
   const auto local_endpoint = std::make_shared<relation_endpoint>(name, relation_type::HasMany, node);
   const auto join_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BelongsTo, nodes_.top());

include/matador/object/repository.hpp

@@ -45,7 +45,7 @@ public:
           if (auto result = attach_node(node, parent); !result) {
               return utils::failure(result.err());
           }
-          foreign_node_completer<Type>::complete(node);
+          foreign_node_completer<Type>::template complete<Type>(node);
           relation_completer<Type>::complete(node);
       } else if (!has_node(name)) {
           it->second->update_name(name);

include/matador/query/constraint.hpp

@@ -11,11 +11,9 @@ namespace matador::query {
 class constraint {
 public:
   constraint() = default;
-  constraint(std::string column_name, std::string table_name, utils::constraints type);
-  constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
+  constraint(std::string column_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
 
   [[nodiscard]] std::string column_name() const;
-  [[nodiscard]] std::string table_name() const;
   [[nodiscard]] const utils::constraints& type() const;
   [[nodiscard]] bool is_primary_key_constraint() const;
   [[nodiscard]] bool is_foreign_key_constraint() const;
@@ -25,7 +23,6 @@ public:
 
 private:
   std::string column_name_;
-  std::string table_name_;
   utils::constraints type_{};
   std::string referenced_table_;
   std::string referenced_column_;

include/matador/query/intermediates/query_alter_table_intermediate.hpp

@@ -1,11 +1,9 @@
 #ifndef MATADOR_QUERY_ALTER_TABLE_INTERMEDIATE_HPP
 #define MATADOR_QUERY_ALTER_TABLE_INTERMEDIATE_HPP
 
-#include "matador/query/intermediates/executable_query.hpp"
-#include "matador/query/intermediates/query_intermediate.hpp"
-#include "matador/query/constraint.hpp"
-
+#include "executable_query.hpp"
 #include "matador/object/restriction.hpp"
+#include "matador/query/intermediates/query_intermediate.hpp"
 
 namespace matador::query {
 class query_add_primary_key_constraint_intermediate final : public executable_query {
@@ -37,9 +35,7 @@ class query_alter_table_intermediate final : public query_intermediate {
 public:
     using query_intermediate::query_intermediate;
 
-    executable_query add_constraint(const object::restriction& rest);
     query_add_key_constraint_intermediate add_constraint(const std::string& name);
-    executable_query drop_constraint(const object::restriction& rest);
     executable_query drop_constraint(const std::string& name);
 };
 }

include/matador/query/internal/query_parts.hpp

@@ -15,8 +15,6 @@
 #include <list>
 #include <memory>
 
-#include "matador/object/restriction.hpp"
-
 namespace matador::query::internal {
 
 class query_alter_part final : public query_part {
@@ -48,19 +46,9 @@ private:
   std::string name_;
 };
 
-class query_add_constraint_part_by_constraint final : public query_part {
+class query_drop_key_constraint_part final : public query_part {
 public:
-  explicit query_add_constraint_part_by_constraint(const constraint& co);
-  void accept(query_part_visitor &visitor) override;
-
-  [[nodiscard]] const class constraint& constraint() const;
-private:
-  class constraint constraint_;
-};
-
-class query_drop_key_constraint_part_by_name final : public query_part {
-public:
-  explicit query_drop_key_constraint_part_by_name(std::string  name);
+  explicit query_drop_key_constraint_part(std::string  name);
   void accept(query_part_visitor &visitor) override;
 
   [[nodiscard]] const std::string& name() const;
@@ -68,16 +56,6 @@ private:
   std::string name_;
 };
 
-class query_drop_key_constraint_part_by_constraint final : public query_part {
-public:
-  explicit query_drop_key_constraint_part_by_constraint(const constraint& co);
-  void accept(query_part_visitor &visitor) override;
-
-  [[nodiscard]] const class constraint& constraint() const;
-private:
-  class constraint constraint_;
-};
-
 class query_add_foreign_key_constraint_part final : public query_part {
 public:
   explicit query_add_foreign_key_constraint_part( const std::vector<column>& columns);
@@ -111,6 +89,12 @@ private:
   std::vector<column> columns_;
 };
 
+class query_drop_foreign_key_constraint_part final : public query_part {
+public:
+    query_drop_foreign_key_constraint_part();
+    void accept(query_part_visitor &visitor) override;
+};
+
 /**
  * Represents the SQL SELECT part
  */

include/matador/query/query_compiler.hpp

@@ -38,9 +38,8 @@ protected:
   void visit(internal::query_add_foreign_key_constraint_part& part) override;
   void visit(internal::query_add_primary_key_constraint_part& part) override;
   void visit(internal::query_add_foreign_key_reference_part& part) override;
-  void visit(internal::query_add_constraint_part_by_constraint &part) override;
-  void visit(internal::query_drop_key_constraint_part_by_name &part) override;
-  void visit(internal::query_drop_key_constraint_part_by_constraint &part) override;
+  void visit(internal::query_drop_key_constraint_part& part) override;
+  void visit(internal::query_drop_foreign_key_constraint_part& part) override;
 
 protected:
   void visit(internal::query_select_part &part) override;
@@ -77,10 +76,6 @@ protected:
   static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const table& t);
   static std::string determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val);
 
-  std::string build_add_constraint_string(const class constraint& c);
-  std::string build_drop_constraint_string(const class constraint& c);
-  std::string build_constraint_name(const class constraint& c);
-
 protected:
   const query_data *data_{};
   sql::query_context query_;

include/matador/query/query_part_visitor.hpp

@@ -7,10 +7,9 @@ namespace internal {
 class query_alter_part;
 class query_alter_table_part;
 class query_add_key_constraint_part;
-class query_drop_key_constraint_part_by_name;
-class query_drop_key_constraint_part_by_constraint;
+class query_drop_key_constraint_part;
+class query_drop_foreign_key_constraint_part;
 class query_add_foreign_key_constraint_part;
-class query_add_constraint_part_by_constraint;
 class query_add_foreign_key_reference_part;
 class query_add_primary_key_constraint_part;
 class query_select_part;
@@ -49,11 +48,10 @@ public:
   virtual void visit(internal::query_alter_table_part &part) = 0;
   virtual void visit(internal::query_add_key_constraint_part &part) = 0;
   virtual void visit(internal::query_add_foreign_key_constraint_part &part) = 0;
-  virtual void visit(internal::query_add_constraint_part_by_constraint &part) = 0;
   virtual void visit(internal::query_add_primary_key_constraint_part &part) = 0;
   virtual void visit(internal::query_add_foreign_key_reference_part &part) = 0;
-  virtual void visit(internal::query_drop_key_constraint_part_by_name &part) = 0;
-  virtual void visit(internal::query_drop_key_constraint_part_by_constraint &part) = 0;
+  virtual void visit(internal::query_drop_key_constraint_part &part) = 0;
+  virtual void visit(internal::query_drop_foreign_key_constraint_part &part) = 0;
 
   virtual void visit(internal::query_select_part &part) = 0;
   virtual void visit(internal::query_from_part &part) = 0;

include/matador/sql/dialect.hpp

@@ -171,7 +171,6 @@ public:
   [[nodiscard]] const std::string& start_quote() const;
   [[nodiscard]] const std::string& string_quote() const;
   [[nodiscard]] const std::string& table() const;
-  [[nodiscard]] const std::string& unique() const;
   [[nodiscard]] const std::string& update() const;
   [[nodiscard]] const std::string& values() const;
   [[nodiscard]] const std::string& where() const;
@@ -238,7 +237,6 @@ private:
     {dialect_token::StartQuote, "\""},
     {dialect_token::StringQuote, "'"},
     {dialect_token::Table,       "TABLE"},
-    {dialect_token::Unique,      "UNIQUE"},
     {dialect_token::Update,      "UPDATE"},
     {dialect_token::Values,      "VALUES"},
     {dialect_token::Where,       "WHERE"}

include/matador/sql/dialect_token.hpp

@@ -55,7 +55,6 @@ enum class dialect_token : uint8_t {
   StartQuote,
   StringQuote,
   Table,
-  Unique,
   Update,
   Values,
   Where

source/orm/orm/schema.cpp

@@ -110,7 +110,7 @@ utils::result<void, utils::error> schema::drop() const {
             }
             auto ctx = query::query::alter()
               .table(node->name())
-              .drop_constraint(cons)
+              .drop_constraint("cons.name()")
               .compile(*c);
 
             std::cout << ctx.sql << std::endl;
@@ -128,7 +128,7 @@ utils::result<void, utils::error> schema::drop() const {
             }
             auto ctx = query::query::alter()
               .table(node->name())
-              .drop_constraint(cons)
+              .drop_constraint("cons.name()")
               .compile(*c);
 
             std::cout << ctx.sql << std::endl;
@@ -185,13 +185,16 @@ sql::query_context schema::build_add_constraint_context( const object::repositor
   if (cons.is_foreign_key_constraint()) {
     return query::query::alter()
       .table(node.name())
-      .add_constraint(cons)
+      .add_constraint("cons.name()")
+      .foreign_key(cons.column_name())
+      .references(cons.ref_table_name(), {cons.ref_column_name()})
       .compile(*pool_.acquire());
   }
   if (cons.is_primary_key_constraint()) {
       return query::query::alter()
       .table(node.name())
-      .add_constraint(cons)
+      .add_constraint("cons.name()")
+      .primary_key(cons.column_name())
       .compile(*pool_.acquire());
   }
   return {};
@@ -200,7 +203,7 @@ sql::query_context schema::build_add_constraint_context( const object::repositor
 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)
+      .drop_constraint("cons.name()")
       .compile(*pool_.acquire());
 }
 }

source/orm/orm/session.cpp

@@ -80,13 +80,16 @@ sql::query_context session::build_add_constraint_context(const std::string& tabl
   if (cons.is_foreign_key_constraint()) {
     return query::query::alter()
       .table(table_name)
-      .add_constraint(cons)
+      .add_constraint("cons.name()")
+      .foreign_key(cons.column_name())
+      .references(cons.ref_table_name(), {cons.ref_column_name()})
       .compile(*conn);
   }
   if (cons.is_primary_key_constraint()) {
     return query::query::alter()
     .table(table_name)
-    .add_constraint(cons)
+    .add_constraint("cons.name()")
+    .primary_key(cons.column_name())
     .compile(*conn);
   }
   return {};
@@ -99,7 +102,7 @@ utils::result<void, utils::error> session::drop_schema() const {
     for (const auto& cons : node->info().constraints()) {
       auto ctx = query::query::alter()
         .table(node->name())
-        .drop_constraint(cons)
+        .drop_constraint("cons.name()")
         .compile(*c);
 
       std::cout << ctx.sql << std::endl;

source/orm/query/constraint.cpp

@@ -3,14 +3,8 @@
 #include "matador/utils/constraints.hpp"
 
 namespace matador::query {
-constraint::constraint(std::string column_name, std::string table_name, utils::constraints type)
+constraint::constraint(std::string column_name, utils::constraints type, std::string referenced_table, std::string referenced_column)
 : column_name_(std::move(column_name))
-, table_name_(std::move(table_name))
-, type_(type) {}
-
-constraint::constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column)
-: column_name_(std::move(column_name))
-, table_name_(std::move(table_name))
 , type_(type)
 , referenced_table_(std::move(referenced_table))
 , referenced_column_(std::move(referenced_column)) {}
@@ -19,10 +13,6 @@ std::string constraint::column_name() const {
   return column_name_;
 }
 
-std::string constraint::table_name() const {
-  return table_name_;
-}
-
 const utils::constraints& constraint::type() const {
   return type_;
 }

source/orm/query/intermediates/query_alter_table_intermediate.cpp

@@ -1,6 +1,5 @@
 #include "matador/query/intermediates/query_alter_table_intermediate.hpp"
 
-#include "matador/object/object.hpp"
 #include "matador/query/internal/query_parts.hpp"
 
 namespace matador::query {
@@ -30,29 +29,14 @@ query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermedi
   return {context_};
 }
 
-executable_query query_alter_table_intermediate::add_constraint(const object::restriction &rest) {
-  context_->parts.push_back(std::make_unique<internal::query_add_constraint_part_by_constraint>(
-    constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()}
-  ));
-
-  return {context_};
-}
-
-query_add_key_constraint_intermediate query_alter_table_intermediate::add_constraint(const std::string& name) {
+query_add_key_constraint_intermediate query_alter_table_intermediate::add_constraint( const std::string& name ) {
     context_->parts.push_back(std::make_unique<internal::query_add_key_constraint_part>(name));
 
     return {context_};
 }
 
-executable_query query_alter_table_intermediate::drop_constraint(const object::restriction &rest) {
-  context_->parts.push_back(std::make_unique<internal::query_drop_key_constraint_part_by_constraint>(
-    constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()})
-  );
-  return {context_};
-}
-
-executable_query query_alter_table_intermediate::drop_constraint(const std::string& name) {
-    context_->parts.push_back(std::make_unique<internal::query_drop_key_constraint_part_by_name>(name));
+executable_query query_alter_table_intermediate::drop_constraint( const std::string& name ) {
+    context_->parts.push_back(std::make_unique<internal::query_drop_key_constraint_part>(name));
     return {context_};
 }
 }

source/orm/query/internal/query_parts.cpp

@@ -34,42 +34,25 @@ const std::string& query_add_key_constraint_part::name() const {
    return name_;
 }
 
-query_add_constraint_part_by_constraint::query_add_constraint_part_by_constraint(const query::constraint &co)
-: query_part(sql::dialect_token::AddConstraint)
-, constraint_(co) {}
-
-void query_add_constraint_part_by_constraint::accept(query_part_visitor &visitor) {
-  visitor.visit(*this);
-}
-
-const class constraint & query_add_constraint_part_by_constraint::constraint() const {
-  return constraint_;
-}
-
-query_drop_key_constraint_part_by_name::query_drop_key_constraint_part_by_name(std::string name)
+query_drop_key_constraint_part::query_drop_key_constraint_part(std::string name)
 : query_part( sql::dialect_token::DropConstraint )
 , name_(std::move( name )){}
 
-void query_drop_key_constraint_part_by_name::accept(query_part_visitor& visitor) {
+void query_drop_key_constraint_part::accept( query_part_visitor& visitor ) {
   visitor.visit(*this);
 }
 
-const std::string& query_drop_key_constraint_part_by_name::name() const {
+const std::string& query_drop_key_constraint_part::name() const {
   return name_;
 }
 
-query_drop_key_constraint_part_by_constraint::query_drop_key_constraint_part_by_constraint(const class constraint &co)
-: query_part( sql::dialect_token::DropConstraint )
-, constraint_(co) {}
+query_drop_foreign_key_constraint_part::query_drop_foreign_key_constraint_part()
+: query_part( sql::dialect_token::DropConstraint ) {}
 
-void query_drop_key_constraint_part_by_constraint::accept(query_part_visitor& visitor) {
+void query_drop_foreign_key_constraint_part::accept( query_part_visitor& visitor ) {
     visitor.visit(*this);
 }
 
-const class constraint& query_drop_key_constraint_part_by_constraint::constraint() const {
-  return constraint_;
-}
-
 query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<column>& columns)
 : query_part(sql::dialect_token::ForeignKey)
 , columns_(columns) {}

source/orm/query/query_compiler.cpp

@@ -117,15 +117,11 @@ void query_compiler::visit(internal::query_add_foreign_key_reference_part& part)
   query_.sql += ")";
 }
 
-void query_compiler::visit(internal::query_add_constraint_part_by_constraint &part) {
-  query_.sql += build_add_constraint_string(part.constraint());
+void query_compiler::visit(internal::query_drop_key_constraint_part& part) {
+    query_.sql += " " + dialect_->token_at(part.token()) + " " + part.name();
 }
 
-void query_compiler::visit(internal::query_drop_key_constraint_part_by_name& part) {
-  query_.sql += " " + dialect_->token_at(part.token()) + " " + part.name();
-}
-
-void query_compiler::visit(internal::query_drop_key_constraint_part_by_constraint& part) {
+void query_compiler::visit(internal::query_drop_foreign_key_constraint_part& part) {
 }
 
 void query_compiler::visit(internal::query_select_part &part) {
@@ -389,13 +385,10 @@ std::string build_create_column(const column &col, const sql::dialect &d) {
     result.append("(" + std::to_string(col.attributes().size()) + ")");
   }
   if (!col.is_nullable()) {
-    result.append(" ").append(d.not_null());
+    result.append(" NOT NULL");
   }
   if (is_constraint_set(col.attributes().options(), utils::constraints::Unique)) {
-    result.append(" ").append(d.unique());
-  }
-  if (is_constraint_set(col.attributes().options(), utils::constraints::PrimaryKey)) {
-    result.append(" ").append(d.primary_key());
+    result.append(" UNIQUE");
   }
 
   return result;
@@ -436,32 +429,4 @@ std::string query_compiler::build_table_name(const sql::dialect_token token, con
     (t.alias().empty() ? "" : " " + d.prepare_identifier_string(t.alias()));
 }
 
-std::string query_compiler::build_add_constraint_string(const class constraint &c) {
-  std::string result = dialect_->add_constraint() + " " + build_constraint_name(c) + " ";
-  if (c.is_primary_key_constraint()) {
-    result.append(dialect_->primary_key()).append(" (").append(c.column_name()).append(")");
-  } else if (c.is_foreign_key_constraint()) {
-    result.append(dialect_->foreign_key()).append(" (").append(c.column_name()).append(") ").append(dialect_->references()).append(" ").append(c.referenced_table()).append(" (").append(c.referenced_column()).append(")");
-  } else if (c.is_unique_constraint()) {
-    result.append(dialect_->unique()).append(" (").append(c.column_name()).append(")");
-  }
-  return result;
-}
-
-std::string query_compiler::build_drop_constraint_string(const class constraint &c) {
-
-}
-
-std::string query_compiler::build_constraint_name(const class constraint &c) {
-  if (c.is_primary_key_constraint()) {
-    return "PK_" + c.table_name();
-  }
-  if (c.is_foreign_key_constraint()) {
-    return "FK_" + c.column_name() + "_" + c.table_name();
-  }
-  if (c.is_unique_constraint()) {
-    return "UK_" + c.column_name() + "_" + c.table_name();
-  }
-  return "";
-}
-}
+}

source/orm/sql/dialect.cpp

@@ -308,10 +308,6 @@ const std::string& dialect::table() const {
   return token_at(dialect_token::Table);
 }
 
-const std::string & dialect::unique() const {
-  return token_at(dialect_token::Unique);
-}
-
 const std::string& dialect::update() const {
   return token_at(dialect_token::Update);
 }