constraint progress

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 "";
+}
+}