constraint, column and table query progress

include/matador/object/restriction.hpp

@@ -1,5 +1,5 @@
-#ifndef MATADOR_CONSTRAINT_HPP
+#ifndef MATADOR_RESTRICTION_HPP
-#define MATADOR_CONSTRAINT_HPP
+#define MATADOR_RESTRICTION_HPP
 
 #include "matador/utils/constraints.hpp"
 
@@ -61,4 +61,4 @@ private:
 // constraint_builder constraint(std::string name);
 
 }
-#endif //MATADOR_CONSTRAINT_HPP
+#endif //MATADOR_RESTRICTION_HPP

include/matador/query/builder.hpp

@@ -2,6 +2,7 @@
 #define MATADOR_BUILDER_HPP
 
 #include "matador/query/column.hpp"
+#include "matador/query/constraint.hpp"
 #include "matador/query/table.hpp"
 
 #include "matador/utils/basic_types.hpp"
@@ -12,18 +13,6 @@
 
 namespace matador::object {
 
-class entity {
-public:
-    explicit entity(std::string name)
-    : name_(std::move(name)) {}
-
-    [[nodiscard]] const std::string& name() const;
-
-private:
-    std::string name_;
-    std::string alias_;
-};
-
 class data_type {
 public:
     explicit data_type(const utils::basic_type type, const size_t size = 0)
@@ -55,6 +44,10 @@ using TinyInt = typed_data_type<int8_t>;
 using SmallInt = typed_data_type<int16_t>;
 using Integer = typed_data_type<int32_t>;
 using BigInt = typed_data_type<int64_t>;
+using TinyIntUnsigned = typed_data_type<uint8_t>;
+using SmallIntUnsigned = typed_data_type<uint16_t>;
+using IntegerUnsigned = typed_data_type<uint32_t>;
+using BigIntUnsigned = typed_data_type<uint64_t>;
 
 using Real = typed_data_type<float>;
 using Double = typed_data_type<double>;
@@ -64,28 +57,6 @@ using Boolean = typed_data_type<bool>;
 using Varchar = sized_typed_data_type<std::string>;
 using Blob = sized_typed_data_type<std::vector<std::byte>>;
 
-class constraint {
-public:
-    explicit constraint(std::string name)
-    : name_(std::move(name)) {}
-
-    [[nodiscard]] const std::string& name() const;
-    [[nodiscard]] std::string column_name() const;
-    [[nodiscard]] const utils::constraints& type() const;
-    [[nodiscard]] bool is_primary_key_constraint() const;
-    [[nodiscard]] bool is_foreign_key_constraint() const;
-    [[nodiscard]] bool is_unique_constraint() const;
-    [[nodiscard]] const std::string& referenced_table() const;
-    [[nodiscard]] const std::string& referenced_column() const;
-
-private:
-    std::string name_;
-    std::string column_name_;
-    utils::constraints type_{};
-    std::string referenced_table_;
-    std::string referenced_column_;
-    data_type dt = Varchar{255};
-};
 }
 namespace matador::query {
 
@@ -94,7 +65,7 @@ public:
   explicit column_builder(std::string column_name, utils::basic_type type, size_t size = 0);
 
   // ReSharper disable once CppNonExplicitConversionOperator
-  operator query::column() const; // NOLINT(*-explicit-constructor)
+  operator column() const; // NOLINT(*-explicit-constructor)
 
   column_builder& not_null();
 
@@ -111,7 +82,7 @@ public:
   table_builder& as(std::string table_alias);
 
   // ReSharper disable once CppNonExplicitConversionOperator
-  operator query::table() const; // NOLINT(*-explicit-constructor)
+  operator table() const; // NOLINT(*-explicit-constructor)
 
 private:
     std::string table_name;
@@ -126,7 +97,7 @@ public:
   constraint_builder& references(std::string table, std::string column);
 
   // ReSharper disable once CppNonExplicitConversionOperator
-  operator object::constraint() const; // NOLINT(*-explicit-constructor)
+  operator class constraint() const; // NOLINT(*-explicit-constructor)
 
 private:
   std::string constraint_name;
@@ -137,8 +108,8 @@ private:
 };
 
 constraint_builder constraint(std::string name);
-table_builder table(std::string name);
+// table_builder table(std::string name);
-column_builder column(std::string name, utils::basic_type type, size_t size = 0);
+// column_builder column(std::string name, utils::basic_type type, size_t size = 0);
 
 }
 #endif //MATADOR_BUILDER_HPP

include/matador/query/column.hpp

@@ -3,6 +3,9 @@
 
 #include "matador/sql/sql_functions.hpp"
 
+#include "matador/utils/basic_types.hpp"
+#include "matador/utils/field_attributes.hpp"
+
 #include <memory>
 #include <string>
 
@@ -25,8 +28,11 @@ public:
 
   [[nodiscard]] const std::string& name() const;
   [[nodiscard]] const std::string& alias() const;
+  [[nodiscard]] utils::basic_type type() const;
+  [[nodiscard]] utils::field_attributes attributes() const;
 
   [[nodiscard]] bool is_function() const;
+  [[nodiscard]] bool is_nullable() const;
   [[nodiscard]] sql::sql_function_t function() const;
   [[nodiscard]] bool has_alias() const;
 
@@ -40,6 +46,8 @@ private:
   std::shared_ptr<query::table> table_;
   std::string name_;
   std::string alias_;
+  utils::basic_type type_{utils::basic_type::Unknown};
+  utils::field_attributes attributes_{};
 
   sql::sql_function_t function_{sql::sql_function_t::None};
 };

include/matador/query/constraint.hpp

@@ -0,0 +1,31 @@
+#ifndef MATADOR_CONSTRAINT_HPP
+#define MATADOR_CONSTRAINT_HPP
+
+#include <string>
+
+namespace matador::utils {
+enum class constraints : unsigned char;
+}
+
+namespace matador::query {
+class constraint {
+public:
+  constraint() = default;
+  constraint(std::string column_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
+
+  [[nodiscard]] std::string column_name() const;
+  [[nodiscard]] const utils::constraints& type() const;
+  [[nodiscard]] bool is_primary_key_constraint() const;
+  [[nodiscard]] bool is_foreign_key_constraint() const;
+  [[nodiscard]] bool is_unique_constraint() const;
+  [[nodiscard]] const std::string& referenced_table() const;
+  [[nodiscard]] const std::string& referenced_column() const;
+
+private:
+  std::string column_name_;
+  utils::constraints type_{};
+  std::string referenced_table_;
+  std::string referenced_column_;
+};
+}
+#endif //MATADOR_CONSTRAINT_HPP

include/matador/query/criteria/criteria_operators.hpp

@@ -4,8 +4,6 @@
 #include "matador/query/criteria/binary_criteria.hpp"
 #include "matador/query/criteria/collection_criteria.hpp"
 
-#include "matador/query/column.hpp"
-
 #include "matador/utils/placeholder.hpp"
 #include "matador/utils/value.hpp"
 
@@ -13,6 +11,7 @@ namespace matador::sql {
 struct query_context;
 }
 namespace matador::query {
+class column;
 
 template<class Type>
 criteria_ptr operator==(const column &col, Type val) {

include/matador/query/intermediates/query_create_intermediate.hpp

@@ -5,6 +5,8 @@
 
 #include "matador/query/intermediates/executable_query.hpp"
 
+#include "matador/query/constraint.hpp"
+
 #include "matador/object/attribute.hpp"
 #include "matador/object/restriction.hpp"
 
@@ -16,16 +18,18 @@ class query_create_table_columns_intermediate : public executable_query {
 public:
   using executable_query::executable_query;
 
-  executable_query constraints(std::initializer_list<class object::restriction> constraints);
+  executable_query constraints(std::initializer_list<object::restriction> constraints);
-  executable_query constraints(const std::list<class object::restriction> &constraints);
+  executable_query constraints(const std::list<object::restriction> &restrictions);
+  executable_query constraints(std::initializer_list<constraint> constraints);
+  executable_query constraints(const std::list<constraint> &restrictions);
 };
 
 class query_create_table_intermediate : public query_intermediate {
 public:
   using query_intermediate::query_intermediate;
 
-  query_create_table_columns_intermediate columns(std::initializer_list<object::attribute> columns);
+  query_create_table_columns_intermediate columns(std::initializer_list<object::attribute> attributes);
-  query_create_table_columns_intermediate columns(const std::list<object::attribute> &columns);
+  query_create_table_columns_intermediate columns(const std::list<object::attribute> &attributes);
   query_create_table_columns_intermediate columns(std::initializer_list<column> columns);
   query_create_table_columns_intermediate columns(const std::list<column> &columns);
 };

include/matador/query/internal/query_parts.hpp

@@ -7,11 +7,9 @@
 #include "matador/query/internal/column_value_pair.hpp"
 #include "matador/query/query_part.hpp"
 #include "matador/query/column.hpp"
+#include "matador/query/constraint.hpp"
 #include "matador/query/table.hpp"
 
-#include "matador/object/attribute.hpp"
-#include "matador/object/restriction.hpp"
-
 #include "matador/utils/placeholder.hpp"
 
 #include <list>
@@ -379,28 +377,28 @@ private:
 
 class query_create_table_columns_part final : public query_part {
 public:
-  explicit query_create_table_columns_part(const std::list<object::attribute> &columns);
+  explicit query_create_table_columns_part(const std::list<column> &columns);
 
- [[nodiscard]] const std::list<object::attribute>& columns() const;
+ [[nodiscard]] const std::list<column>& columns() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  std::list<object::attribute> columns_;
+  std::list<column> columns_;
 };
 
 class query_create_table_constraints_part final : public query_part {
 public:
-  explicit query_create_table_constraints_part(const std::list<class object::restriction> &constraints);
+  explicit query_create_table_constraints_part(const std::list<constraint> &constraints);
 
-  [[nodiscard]] const std::list<class object::restriction>& constraints() const;
+  [[nodiscard]] const std::list<constraint>& constraints() const;
 
 private:
   void accept(query_part_visitor &visitor) override;
 
 private:
-  std::list<class object::restriction> constraints_;
+  std::list<constraint> constraints_;
 };
 
 class query_create_schema_part final : public query_part {

include/matador/query/table.hpp

@@ -1,15 +1,13 @@
 #ifndef QUERY_TABLE_HPP
 #define QUERY_TABLE_HPP
 
-#include "column.hpp"
+#include "matador/query/column.hpp"
 
 #include <string>
 #include <vector>
 
 namespace matador::query {
 
-class column;
-
 // ReSharper disable CppNonExplicitConvertingConstructor
 class table {
 public:
@@ -17,7 +15,7 @@ public:
   table(const char *name); // NOLINT(*-explicit-constructor)
   table(std::string name); // NOLINT(*-explicit-constructor)
   table(std::string name, std::string as);
-  table(std::string name, std::string as, const std::vector<class column> &columns);
+  table(std::string name, std::string as, const std::vector<column> &columns);
 
   table as(const std::string &a);
 
@@ -29,7 +27,7 @@ public:
 
   [[nodiscard]] const std::string& name() const;
   [[nodiscard]] const std::string& alias() const;
-  [[nodiscard]] const std::vector<class column>& columns() const;
+  [[nodiscard]] const std::vector<column>& columns() const;
 
   // ReSharper disable once CppNonExplicitConversionOperator
   operator const std::vector<query::column>&() const; // NOLINT(*-explicit-constructor)
@@ -40,7 +38,7 @@ private:
   std::string alias_;
 
   std::string schema_name_;
-  std::vector<query::column> columns_;
+  std::vector<column> columns_;
 };
 
 table operator ""_tab(const char *name, size_t len);

include/matador/utils/constraints.hpp

@@ -9,7 +9,8 @@ enum class constraints : unsigned char {
   Unique =      1 << 1,
   PrimaryKey = 1 << 2,
   ForeignKey = 1 << 3,
-  Default =     1 << 4
+  Default =     1 << 4,
+  NotNull =     1 << 5
 };
 
 inline constraints operator|(constraints a, constraints b) { return static_cast<constraints>(static_cast<unsigned int>(a) | static_cast<unsigned int>(b)); }

source/orm/CMakeLists.txt

@@ -6,6 +6,7 @@ add_library(matador-orm STATIC
   ../../include/matador/query/attribute_string_writer.hpp
   ../../include/matador/query/builder.hpp
   ../../include/matador/query/column.hpp
+  ../../include/matador/query/constraint.hpp
   ../../include/matador/query/criteria.hpp
   ../../include/matador/query/criteria/abstract_column_criteria.hpp
   ../../include/matador/query/criteria/abstract_criteria.hpp
@@ -91,6 +92,7 @@ add_library(matador-orm STATIC
   query/attribute_string_writer.cpp
   query/builder.cpp
   query/column.cpp
+  query/constraint.cpp
   query/criteria/abstract_column_criteria.cpp
   query/criteria/between_criteria.cpp
   query/criteria/binary_criteria.cpp

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

source/orm/orm/session.cpp

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

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 {
+constraint_builder::operator class constraint() const {
-  return object::restriction{constraint_name};
+  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) {
+query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list<object::attribute> attributes) {
-  context_->parts.push_back(std::make_unique<internal::query_create_table_columns_part>(columns));
+  return columns(std::list(attributes));
-  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>& 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_create_column(const column &col, const sql::dialect &d);
-std::string build_constraint(const class object::restriction &cons, 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()) {
+    // if (!cons.name().empty()) {
-        result.append(d.constraint()).append(" ").append(cons.name()).append(" ");
+        // 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

test/core/object/SchemaTest.cpp

@@ -105,8 +105,14 @@ TEST_CASE("Test one to many", "[relation][one-to-many]") {
   REQUIRE(repo.contains("departments"));
   REQUIRE(repo.contains("employees"));
 
-  std::cout << *repo.basic_info("departments")->get().object();
+  auto info = repo.basic_info("departments")->get();
-  std::cout << *repo.basic_info("employees")->get().object();
+  REQUIRE(!info.endpoints_empty());
+  REQUIRE(info.endpoints_size() == 1);
+  std::cout << *info.object();
+  info = repo.basic_info("employees")->get();
+  REQUIRE(!info.endpoints_empty());
+  REQUIRE(info.endpoints_size() == 1);
+  std::cout << *info.object();
 }
 
 TEST_CASE("Test one to many reverse", "[relation][one-to-many][reverse]") {
@@ -121,8 +127,14 @@ TEST_CASE("Test one to many reverse", "[relation][one-to-many][reverse]") {
   REQUIRE(repo.contains("departments"));
   REQUIRE(repo.contains("employees"));
 
-  std::cout << *repo.basic_info("departments")->get().object();
+  auto info = repo.basic_info("departments")->get();
-  std::cout << *repo.basic_info("employees")->get().object();
+  REQUIRE(!info.endpoints_empty());
+  REQUIRE(info.endpoints_size() == 1);
+  std::cout << *info.object();
+  info = repo.basic_info("employees")->get();
+  REQUIRE(!info.endpoints_empty());
+  REQUIRE(info.endpoints_size() == 1);
+  std::cout << *info.object();
 }
 
 TEST_CASE("Test many to many relation", "[relation][many-to-many]") {
@@ -142,4 +154,18 @@ TEST_CASE("Test many to many relation", "[relation][many-to-many]") {
   std::cout << *repo.basic_info("ingredients")->get().object();
   std::cout << *repo.basic_info("recipes")->get().object();
   std::cout << *repo.basic_info("recipe_ingredients")->get().object();
+
+
+  auto info = repo.basic_info("ingredients")->get();
+  REQUIRE(!info.endpoints_empty());
+  REQUIRE(info.endpoints_size() == 1);
+  std::cout << *info.object();
+  info = repo.basic_info("recipes")->get();
+  REQUIRE(!info.endpoints_empty());
+  REQUIRE(info.endpoints_size() == 1);
+  std::cout << *info.object();
+  info = repo.basic_info("recipe_ingredients")->get();
+  REQUIRE(!info.endpoints_empty());
+  REQUIRE(info.endpoints_size() == 2);
+  std::cout << *info.object();
 }

test/orm/query/QueryBuilderTest.cpp

@@ -5,6 +5,8 @@
 #include <matador/query/criteria.hpp>
 #include <matador/query/query.hpp>
 #include "matador/query/table.hpp"
+#include "matador/query/column.hpp"
+#include "matador/query/builder.hpp"
 
 #include "matador/sql/connection.hpp"