constraint, column and table query progress

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::restriction() const {
-  return object::restriction{constraint_name};
+constraint_builder::operator class constraint() const {
+  return {};
 }
 
 constraint_builder constraint( std::string name ) {
@@ -61,7 +61,7 @@ table_builder table( std::string name ) {
 return table_builder(std::move(name));
 }
 
-column_builder column(std::string name, const utils::basic_type type, size_t size) {
+column_builder column(std::string name, const utils::basic_type type, const size_t size) {
   return column_builder(std::move(name), type, size);
 }
 

source/orm/query/column.cpp

@@ -61,10 +61,22 @@ const std::string& column::alias() const {
   return alias_;
 }
 
+utils::basic_type column::type() const {
+  return type_;
+}
+
+utils::field_attributes column::attributes() const {
+  return attributes_;
+}
+
 bool column::is_function() const {
   return function_ != sql::sql_function_t::None;
 }
 
+bool column::is_nullable() const {
+  return !utils::is_constraint_set(attributes_.options(), utils::constraints::NotNull);
+}
+
 sql::sql_function_t column::function() const {
   return function_;
 }

source/orm/query/constraint.cpp

@@ -0,0 +1,39 @@
+#include "matador/query/constraint.hpp"
+
+#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)
+: column_name_(std::move(column_name))
+, type_(type)
+, referenced_table_(std::move(referenced_table))
+, referenced_column_(std::move(referenced_column)) {}
+
+std::string constraint::column_name() const {
+  return column_name_;
+}
+
+const utils::constraints& constraint::type() const {
+  return type_;
+}
+
+bool constraint::is_primary_key_constraint() const {
+  return utils::is_constraint_set(type_, utils::constraints::PrimaryKey);
+}
+
+bool constraint::is_foreign_key_constraint() const {
+  return utils::is_constraint_set(type_, utils::constraints::ForeignKey);
+}
+
+bool constraint::is_unique_constraint() const {
+  return utils::is_constraint_set(type_, utils::constraints::Unique);
+}
+
+const std::string& constraint::referenced_table() const {
+  return referenced_table_;
+}
+
+const std::string& constraint::referenced_column() const {
+  return referenced_column_;
+}
+}

source/orm/query/intermediates/query_create_intermediate.cpp

@@ -2,6 +2,10 @@
 
 #include "matador/query/internal/query_parts.hpp"
 
+#include "matador/query/constraint.hpp"
+
+#include <vector>
+
 namespace matador::query {
 
 query_create_intermediate::query_create_intermediate() {
@@ -18,22 +22,36 @@ executable_query query_create_intermediate::schema( const std::string& schema_na
   return {context_};
 }
 
-executable_query query_create_table_columns_intermediate::constraints(const std::initializer_list<class object::restriction> constraints) {
+executable_query query_create_table_columns_intermediate::constraints(const std::initializer_list<object::restriction> constraints) {
   return this->constraints(std::list(constraints));
 }
 
-executable_query query_create_table_columns_intermediate::constraints(const std::list<class object::restriction>& constraints) {
+executable_query query_create_table_columns_intermediate::constraints(std::initializer_list<constraint> constraints) {
+  return {context_};
+}
 
+executable_query query_create_table_columns_intermediate::constraints(const std::list<constraint>& restrictions){
+  return {context_};
+}
+
+executable_query query_create_table_columns_intermediate::constraints(const std::list<object::restriction>& restrictions) {
+  std::list<constraint> constraints;
+  for ( const auto& restr : restrictions ) {
+
+  }
   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) {
-  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<object::attribute> attributes) {
+  return columns(std::list(attributes));
 }
 
-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>& attributes) {
+  std::list<column> columns;
+  for (const auto& attr : attributes) {
+
+  }
   context_->parts.push_back(std::make_unique<internal::query_create_table_columns_part>(columns));
   return {context_};
 }

source/orm/query/internal/query_parts.cpp

@@ -358,11 +358,11 @@ void query_create_table_part::accept(query_part_visitor &visitor)
   visitor.visit(*this);
 }
 
-query_create_table_columns_part::query_create_table_columns_part(const std::list<object::attribute>& columns)
+query_create_table_columns_part::query_create_table_columns_part(const std::list<column>& columns)
 : query_part( sql::dialect_token::Columns )
 , columns_(columns){}
 
-const std::list<object::attribute>& query_create_table_columns_part::columns() const {
+const std::list<column>& query_create_table_columns_part::columns() const {
   return columns_;
 }
 
@@ -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::restriction>& constraints)
+query_create_table_constraints_part::query_create_table_constraints_part(const std::list<class constraint>& constraints)
 : query_part( sql::dialect_token::Constraint )
 , constraints_(constraints) {}
 
-const std::list<class object::restriction>& query_create_table_constraints_part::constraints() const {
+const std::list<class constraint>& query_create_table_constraints_part::constraints() const {
   return constraints_;
 }
 

source/orm/query/query_compiler.cpp

@@ -4,6 +4,8 @@
 #include "matador/query/query_data.hpp"
 #include "matador/query/criteria_evaluator.hpp"
 #include "matador/query/query_utils.hpp"
+#include "matador/query/constraint.hpp"
+#include "matador/query/column.hpp"
 
 #include "matador/query/internal/basic_type_to_string_visitor.hpp"
 #include "matador/query/internal/query_parts.hpp"
@@ -293,8 +295,8 @@ void query_compiler::visit(internal::query_create_part &/*create_part*/)
   query_.sql = dialect_->create();
 }
 
-std::string build_create_column(const object::attribute &col, const sql::dialect &d);
-std::string build_constraint(const class object::restriction &cons, const sql::dialect &d);
+std::string build_create_column(const column &col, const sql::dialect &d);
+std::string build_constraint(const class constraint &cons, const sql::dialect &d);
 
 void query_compiler::visit(internal::query_create_table_part &part)
 {
@@ -377,7 +379,7 @@ void query_compiler::visit(internal::query_drop_table_part &part) {
   query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
 }
 
-std::string build_create_column(const object::attribute &col, const sql::dialect &d) {
+std::string build_create_column(const column &col, const sql::dialect &d) {
   std::string result = d.prepare_identifier_string(col.name()) + " " + d.data_type_at(col.type());
   if (col.attributes().size() > 0) {
     result.append("(" + std::to_string(col.attributes().size()) + ")");
@@ -392,11 +394,11 @@ std::string build_create_column(const object::attribute &col, const sql::dialect
   return result;
 }
 
-std::string build_constraint(const class object::restriction& cons, const sql::dialect& d) {
+std::string build_constraint(const constraint& cons, const sql::dialect& d) {
     std::string result;
-    if (!cons.name().empty()) {
-        result.append(d.constraint()).append(" ").append(cons.name()).append(" ");
-    }
+    // if (!cons.name().empty()) {
+        // result.append(d.constraint()).append(" ").append(cons.name()).append(" ");
+    // }
     if (cons.is_primary_key_constraint()) {
         result
             .append(d.primary_key())
@@ -410,9 +412,9 @@ std::string build_constraint(const class object::restriction& cons, const sql::d
             .append(cons.column_name())
             .append(") ")
             .append(d.references()).append(" ")
-            .append(cons.ref_table_name())
+            .append(cons.referenced_table())
             .append(" (")
-            .append(cons.ref_column_name())
+            .append(cons.referenced_column())
             .append(")");
     } else {
         // handle error