constraint progress

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.name()")
+              .drop_constraint(cons)
               .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.name()")
+              .drop_constraint(cons)
               .compile(*c);
 
             std::cout << ctx.sql << std::endl;
@@ -185,16 +185,13 @@ 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.name()")
-      .foreign_key(cons.column_name())
-      .references(cons.ref_table_name(), {cons.ref_column_name()})
+      .add_constraint(cons)
       .compile(*pool_.acquire());
   }
   if (cons.is_primary_key_constraint()) {
       return query::query::alter()
       .table(node.name())
-      .add_constraint("cons.name()")
-      .primary_key(cons.column_name())
+      .add_constraint(cons)
       .compile(*pool_.acquire());
   }
   return {};
@@ -203,7 +200,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.name()")
+      .drop_constraint(cons)
       .compile(*pool_.acquire());
 }
 }

source/orm/orm/session.cpp

@@ -80,16 +80,13 @@ 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.name()")
-      .foreign_key(cons.column_name())
-      .references(cons.ref_table_name(), {cons.ref_column_name()})
+      .add_constraint(cons)
       .compile(*conn);
   }
   if (cons.is_primary_key_constraint()) {
     return query::query::alter()
     .table(table_name)
-    .add_constraint("cons.name()")
-    .primary_key(cons.column_name())
+    .add_constraint(cons)
     .compile(*conn);
   }
   return {};
@@ -102,7 +99,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.name()")
+        .drop_constraint(cons)
         .compile(*c);
 
       std::cout << ctx.sql << std::endl;

source/orm/query/constraint.cpp

@@ -3,8 +3,14 @@
 #include "matador/utils/constraints.hpp"
 
 namespace matador::query {
-constraint::constraint(std::string column_name, utils::constraints type, std::string referenced_table, std::string referenced_column)
+constraint::constraint(std::string column_name, std::string table_name, utils::constraints type)
 : 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)) {}
@@ -13,6 +19,10 @@ 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,5 +1,6 @@
 #include "matador/query/intermediates/query_alter_table_intermediate.hpp"
 
+#include "matador/object/object.hpp"
 #include "matador/query/internal/query_parts.hpp"
 
 namespace matador::query {
@@ -29,14 +30,29 @@ query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermedi
   return {context_};
 }
 
-query_add_key_constraint_intermediate query_alter_table_intermediate::add_constraint( const std::string& name ) {
+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) {
     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 std::string& name ) {
-    context_->parts.push_back(std::make_unique<internal::query_drop_key_constraint_part>(name));
+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));
     return {context_};
 }
 }

source/orm/query/internal/query_parts.cpp

@@ -34,25 +34,42 @@ const std::string& query_add_key_constraint_part::name() const {
    return name_;
 }
 
-query_drop_key_constraint_part::query_drop_key_constraint_part(std::string name)
-: query_part( sql::dialect_token::DropConstraint )
-, name_(std::move( 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_drop_key_constraint_part::accept( query_part_visitor& visitor ) {
+void query_add_constraint_part_by_constraint::accept(query_part_visitor &visitor) {
   visitor.visit(*this);
 }
 
-const std::string& query_drop_key_constraint_part::name() const {
+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_part( sql::dialect_token::DropConstraint )
+, name_(std::move( name )){}
+
+void query_drop_key_constraint_part_by_name::accept(query_part_visitor& visitor) {
+  visitor.visit(*this);
+}
+
+const std::string& query_drop_key_constraint_part_by_name::name() const {
   return name_;
 }
 
-query_drop_foreign_key_constraint_part::query_drop_foreign_key_constraint_part()
-: query_part( sql::dialect_token::DropConstraint ) {}
+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) {}
 
-void query_drop_foreign_key_constraint_part::accept( query_part_visitor& visitor ) {
+void query_drop_key_constraint_part_by_constraint::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,11 +117,15 @@ void query_compiler::visit(internal::query_add_foreign_key_reference_part& part)
   query_.sql += ")";
 }
 
-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_add_constraint_part_by_constraint &part) {
+  query_.sql += build_add_constraint_string(part.constraint());
 }
 
-void query_compiler::visit(internal::query_drop_foreign_key_constraint_part& part) {
+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_select_part &part) {
@@ -385,10 +389,13 @@ 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(" NOT NULL");
+    result.append(" ").append(d.not_null());
   }
   if (is_constraint_set(col.attributes().options(), utils::constraints::Unique)) {
-    result.append(" UNIQUE");
+    result.append(" ").append(d.unique());
+  }
+  if (is_constraint_set(col.attributes().options(), utils::constraints::PrimaryKey)) {
+    result.append(" ").append(d.primary_key());
   }
 
   return result;
@@ -429,4 +436,32 @@ 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,6 +308,10 @@ 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);
 }