From 9ba58eb05b74ab56827e0d633c6b876e0da4ab10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sascha=20K=C3=BChl?= Date: Fri, 12 Dec 2025 15:49:30 +0100 Subject: [PATCH] constraint, column and table query progress --- include/matador/object/restriction.hpp | 6 +-- include/matador/query/builder.hpp | 49 ++++--------------- include/matador/query/column.hpp | 8 +++ include/matador/query/constraint.hpp | 31 ++++++++++++ .../query/criteria/criteria_operators.hpp | 3 +- .../query_create_intermediate.hpp | 12 +++-- .../matador/query/internal/query_parts.hpp | 16 +++--- include/matador/query/table.hpp | 10 ++-- include/matador/utils/constraints.hpp | 3 +- source/orm/CMakeLists.txt | 2 + source/orm/orm/schema.cpp | 10 ++-- source/orm/orm/session.cpp | 6 +-- source/orm/query/builder.cpp | 6 +-- source/orm/query/column.cpp | 12 +++++ source/orm/query/constraint.cpp | 39 +++++++++++++++ .../query_create_intermediate.cpp | 30 +++++++++--- source/orm/query/internal/query_parts.cpp | 8 +-- source/orm/query/query_compiler.cpp | 20 ++++---- test/core/object/SchemaTest.cpp | 34 +++++++++++-- test/orm/query/QueryBuilderTest.cpp | 2 + 20 files changed, 209 insertions(+), 98 deletions(-) create mode 100644 include/matador/query/constraint.hpp create mode 100644 source/orm/query/constraint.cpp diff --git a/include/matador/object/restriction.hpp b/include/matador/object/restriction.hpp index 98dc8d4..bdd105e 100644 --- a/include/matador/object/restriction.hpp +++ b/include/matador/object/restriction.hpp @@ -1,5 +1,5 @@ -#ifndef MATADOR_CONSTRAINT_HPP -#define MATADOR_CONSTRAINT_HPP +#ifndef MATADOR_RESTRICTION_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 \ No newline at end of file +#endif //MATADOR_RESTRICTION_HPP \ No newline at end of file diff --git a/include/matador/query/builder.hpp b/include/matador/query/builder.hpp index 3b9ccda..c89d4f1 100644 --- a/include/matador/query/builder.hpp +++ b/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; using SmallInt = typed_data_type; using Integer = typed_data_type; using BigInt = typed_data_type; +using TinyIntUnsigned = typed_data_type; +using SmallIntUnsigned = typed_data_type; +using IntegerUnsigned = typed_data_type; +using BigIntUnsigned = typed_data_type; using Real = typed_data_type; using Double = typed_data_type; @@ -64,28 +57,6 @@ using Boolean = typed_data_type; using Varchar = sized_typed_data_type; using Blob = sized_typed_data_type>; -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); -column_builder column(std::string name, utils::basic_type type, size_t size = 0); +// table_builder table(std::string name); +// column_builder column(std::string name, utils::basic_type type, size_t size = 0); } #endif //MATADOR_BUILDER_HPP \ No newline at end of file diff --git a/include/matador/query/column.hpp b/include/matador/query/column.hpp index bf01b6b..db8acac 100644 --- a/include/matador/query/column.hpp +++ b/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 #include @@ -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 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}; }; diff --git a/include/matador/query/constraint.hpp b/include/matador/query/constraint.hpp new file mode 100644 index 0000000..293dcbc --- /dev/null +++ b/include/matador/query/constraint.hpp @@ -0,0 +1,31 @@ +#ifndef MATADOR_CONSTRAINT_HPP +#define MATADOR_CONSTRAINT_HPP + +#include + +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 \ No newline at end of file diff --git a/include/matador/query/criteria/criteria_operators.hpp b/include/matador/query/criteria/criteria_operators.hpp index d39db25..4e7fd59 100644 --- a/include/matador/query/criteria/criteria_operators.hpp +++ b/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 criteria_ptr operator==(const column &col, Type val) { diff --git a/include/matador/query/intermediates/query_create_intermediate.hpp b/include/matador/query/intermediates/query_create_intermediate.hpp index babd778..5eea57e 100644 --- a/include/matador/query/intermediates/query_create_intermediate.hpp +++ b/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 constraints); - executable_query constraints(const std::list &constraints); + executable_query constraints(std::initializer_list constraints); + executable_query constraints(const std::list &restrictions); + executable_query constraints(std::initializer_list constraints); + executable_query constraints(const std::list &restrictions); }; class query_create_table_intermediate : public query_intermediate { public: using query_intermediate::query_intermediate; - query_create_table_columns_intermediate columns(std::initializer_list columns); - query_create_table_columns_intermediate columns(const std::list &columns); + query_create_table_columns_intermediate columns(std::initializer_list attributes); + query_create_table_columns_intermediate columns(const std::list &attributes); query_create_table_columns_intermediate columns(std::initializer_list columns); query_create_table_columns_intermediate columns(const std::list &columns); }; diff --git a/include/matador/query/internal/query_parts.hpp b/include/matador/query/internal/query_parts.hpp index 2d9fe77..3c70fc4 100644 --- a/include/matador/query/internal/query_parts.hpp +++ b/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 @@ -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 &columns); + explicit query_create_table_columns_part(const std::list &columns); - [[nodiscard]] const std::list& columns() const; + [[nodiscard]] const std::list& columns() const; private: void accept(query_part_visitor &visitor) override; private: - std::list columns_; + std::list columns_; }; class query_create_table_constraints_part final : public query_part { public: - explicit query_create_table_constraints_part(const std::list &constraints); + explicit query_create_table_constraints_part(const std::list &constraints); - [[nodiscard]] const std::list& constraints() const; + [[nodiscard]] const std::list& constraints() const; private: void accept(query_part_visitor &visitor) override; private: - std::list constraints_; + std::list constraints_; }; class query_create_schema_part final : public query_part { diff --git a/include/matador/query/table.hpp b/include/matador/query/table.hpp index 0a95ef1..269cf03 100644 --- a/include/matador/query/table.hpp +++ b/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 #include 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 &columns); + table(std::string name, std::string as, const std::vector &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& columns() const; + [[nodiscard]] const std::vector& columns() const; // ReSharper disable once CppNonExplicitConversionOperator operator const std::vector&() const; // NOLINT(*-explicit-constructor) @@ -40,7 +38,7 @@ private: std::string alias_; std::string schema_name_; - std::vector columns_; + std::vector columns_; }; table operator ""_tab(const char *name, size_t len); diff --git a/include/matador/utils/constraints.hpp b/include/matador/utils/constraints.hpp index e445be4..99e8e62 100644 --- a/include/matador/utils/constraints.hpp +++ b/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(static_cast(a) | static_cast(b)); } diff --git a/source/orm/CMakeLists.txt b/source/orm/CMakeLists.txt index 2e45154..72d8cf3 100644 --- a/source/orm/CMakeLists.txt +++ 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 diff --git a/source/orm/orm/schema.cpp b/source/orm/orm/schema.cpp index fb5d119..dd71be9 100644 --- a/source/orm/orm/schema.cpp +++ b/source/orm/orm/schema.cpp @@ -110,7 +110,7 @@ utils::result 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 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()); } } \ No newline at end of file diff --git a/source/orm/orm/session.cpp b/source/orm/orm/session.cpp index 7fd785f..a577984 100644 --- a/source/orm/orm/session.cpp +++ b/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 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; diff --git a/source/orm/query/builder.cpp b/source/orm/query/builder.cpp index 87aba7f..292d6cc 100644 --- a/source/orm/query/builder.cpp +++ b/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); } diff --git a/source/orm/query/column.cpp b/source/orm/query/column.cpp index 1a7ed87..5f0e39e 100644 --- a/source/orm/query/column.cpp +++ b/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_; } diff --git a/source/orm/query/constraint.cpp b/source/orm/query/constraint.cpp new file mode 100644 index 0000000..7f7d76f --- /dev/null +++ b/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_; +} +} diff --git a/source/orm/query/intermediates/query_create_intermediate.cpp b/source/orm/query/intermediates/query_create_intermediate.cpp index d641943..6b06287 100644 --- a/source/orm/query/intermediates/query_create_intermediate.cpp +++ b/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 + 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 constraints) { +executable_query query_create_table_columns_intermediate::constraints(const std::initializer_list constraints) { return this->constraints(std::list(constraints)); } -executable_query query_create_table_columns_intermediate::constraints(const std::list& constraints) { +executable_query query_create_table_columns_intermediate::constraints(std::initializer_list constraints) { + return {context_}; +} +executable_query query_create_table_columns_intermediate::constraints(const std::list& restrictions){ + return {context_}; +} + +executable_query query_create_table_columns_intermediate::constraints(const std::list& restrictions) { + std::list constraints; + for ( const auto& restr : restrictions ) { + + } context_->parts.push_back(std::make_unique(constraints)); return {context_}; } -query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list columns) { - context_->parts.push_back(std::make_unique(columns)); - return {context_}; +query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list attributes) { + return columns(std::list(attributes)); } -query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list& columns) { +query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list& attributes) { + std::list columns; + for (const auto& attr : attributes) { + + } context_->parts.push_back(std::make_unique(columns)); return {context_}; } diff --git a/source/orm/query/internal/query_parts.cpp b/source/orm/query/internal/query_parts.cpp index 45dd29c..a0194f2 100644 --- a/source/orm/query/internal/query_parts.cpp +++ b/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& columns) +query_create_table_columns_part::query_create_table_columns_part(const std::list& columns) : query_part( sql::dialect_token::Columns ) , columns_(columns){} -const std::list& query_create_table_columns_part::columns() const { +const std::list& 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& constraints) +query_create_table_constraints_part::query_create_table_constraints_part(const std::list& constraints) : query_part( sql::dialect_token::Constraint ) , constraints_(constraints) {} -const std::list& query_create_table_constraints_part::constraints() const { +const std::list& query_create_table_constraints_part::constraints() const { return constraints_; } diff --git a/source/orm/query/query_compiler.cpp b/source/orm/query/query_compiler.cpp index 697ba89..7624fe4 100644 --- a/source/orm/query/query_compiler.cpp +++ b/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 diff --git a/test/core/object/SchemaTest.cpp b/test/core/object/SchemaTest.cpp index a0870a0..9b9896d 100644 --- a/test/core/object/SchemaTest.cpp +++ b/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(); - std::cout << *repo.basic_info("employees")->get().object(); + auto info = repo.basic_info("departments")->get(); + 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(); - std::cout << *repo.basic_info("employees")->get().object(); + auto info = repo.basic_info("departments")->get(); + 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(); } diff --git a/test/orm/query/QueryBuilderTest.cpp b/test/orm/query/QueryBuilderTest.cpp index c30cde4..7fc8996 100644 --- a/test/orm/query/QueryBuilderTest.cpp +++ b/test/orm/query/QueryBuilderTest.cpp @@ -5,6 +5,8 @@ #include #include #include "matador/query/table.hpp" +#include "matador/query/column.hpp" +#include "matador/query/builder.hpp" #include "matador/sql/connection.hpp"