From b9d35cbd4e1d0056539daaa02743fd9149ab2bb5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sascha=20K=C3=BChl?= Date: Wed, 31 Dec 2025 13:01:06 +0100 Subject: [PATCH] renamed column to table_column and constraint to table_constraint. --- demo/main.cpp | 28 ++++---- include/matador/orm/session.hpp | 53 +++++++------- include/matador/orm/session_query_builder.hpp | 30 ++++---- include/matador/query/builder.hpp | 8 +-- .../criteria/abstract_column_criteria.hpp | 8 +-- .../query/criteria/between_criteria.hpp | 4 +- .../query/criteria/binary_criteria.hpp | 14 ++-- .../query/criteria/collection_criteria.hpp | 8 +-- .../query/criteria/criteria_operators.hpp | 56 +++++++-------- .../matador/query/criteria/like_criteria.hpp | 4 +- include/matador/query/generator.hpp | 12 ++-- .../query_alter_table_intermediate.hpp | 14 ++-- .../query_create_intermediate.hpp | 10 +-- .../query_execute_where_intermediate.hpp | 2 +- .../intermediates/query_from_intermediate.hpp | 4 +- .../query_group_by_intermediate.hpp | 2 +- .../query_insert_intermediate.hpp | 4 +- .../query_select_intermediate.hpp | 2 +- .../query_where_intermediate.hpp | 4 +- .../query/internal/column_value_pair.hpp | 8 +-- .../matador/query/internal/query_parts.hpp | 70 +++++++++---------- include/matador/query/query.hpp | 14 ++-- include/matador/query/query_compiler.hpp | 8 ++- include/matador/query/query_utils.hpp | 6 +- include/matador/query/table.hpp | 20 +++--- .../query/{column.hpp => table_column.hpp} | 28 ++++---- .../{constraint.hpp => table_constraint.hpp} | 10 +-- include/matador/sql/query_macro.hpp | 2 +- source/orm/CMakeLists.txt | 8 +-- source/orm/orm/session.cpp | 12 ++-- source/orm/orm/session_query_builder.cpp | 4 +- source/orm/query/builder.cpp | 4 +- .../criteria/abstract_column_criteria.cpp | 4 +- .../orm/query/criteria/between_criteria.cpp | 4 +- source/orm/query/criteria/binary_criteria.cpp | 8 +-- .../query/criteria/collection_criteria.cpp | 8 +-- .../orm/query/criteria/criteria_operators.cpp | 38 +++++----- source/orm/query/criteria/like_criteria.cpp | 4 +- .../query_alter_table_intermediate.cpp | 14 ++-- .../query_create_intermediate.cpp | 14 ++-- .../query_execute_where_intermediate.cpp | 2 +- .../intermediates/query_from_intermediate.cpp | 4 +- .../query_group_by_intermediate.cpp | 2 +- .../query_insert_intermediate.cpp | 8 +-- .../query_select_intermediate.cpp | 2 +- .../query_where_intermediate.cpp | 4 +- .../orm/query/internal/column_value_pair.cpp | 4 +- source/orm/query/internal/query_parts.cpp | 44 ++++++------ source/orm/query/query.cpp | 18 ++--- source/orm/query/query_compiler.cpp | 20 +++--- source/orm/query/query_utils.cpp | 4 +- source/orm/query/schema.cpp | 2 +- source/orm/query/table.cpp | 14 ++-- .../query/{column.cpp => table_column.cpp} | 56 +++++++-------- .../{constraint.cpp => table_constraint.cpp} | 26 +++---- test/backends/QueryRecordTest.cpp | 2 +- test/backends/QueryStatementTests.cpp | 2 +- test/backends/QueryTest.cpp | 46 ++++++------ test/orm/orm/SessionQueryBuilderTest.cpp | 20 +++--- test/orm/query/GeneratorTests.cpp | 2 +- test/orm/query/QueryBuilderTest.cpp | 6 +- test/orm/sql/ColumnGeneratorTest.cpp | 4 +- 62 files changed, 424 insertions(+), 423 deletions(-) rename include/matador/query/{column.hpp => table_column.hpp} (57%) rename include/matador/query/{constraint.hpp => table_constraint.hpp} (62%) rename source/orm/query/{column.cpp => table_column.cpp} (59%) rename source/orm/query/{constraint.cpp => table_constraint.cpp} (57%) diff --git a/demo/main.cpp b/demo/main.cpp index d80af68..ae9bfed 100644 --- a/demo/main.cpp +++ b/demo/main.cpp @@ -144,20 +144,20 @@ struct matador::utils::data_type_traits { } }; -QUERY_HELPER( authors, AUTHOR, id, first_name, last_name, date_of_birth, year_of_birth, distinguished ) - -QUERY_HELPER( books, BOOK, id, author_id, title, published_in ) - -QUERY_HELPER( job, JOB, id, payload, type, description, state, mode ) - -QUERY_HELPER( payload, PAYLOAD, id ) - -QUERY_HELPER( temporary_table, TEMPORARY_TABLE, id ); - -QUERY_HELPER(customer, CUSTOMER, id, name, email, address) -QUERY_HELPER(product, PRODUCT, id, title, description, price, category) -QUERY_HELPER(category, CATEGORY, id, title, description) -QUERY_HELPER(cart, CART, id, items, owner) +// QUERY_HELPER( authors, AUTHOR, id, first_name, last_name, date_of_birth, year_of_birth, distinguished ) +// +// QUERY_HELPER( books, BOOK, id, author_id, title, published_in ) +// +// QUERY_HELPER( job, JOB, id, payload, type, description, state, mode ) +// +// QUERY_HELPER( payload, PAYLOAD, id ) +// +// QUERY_HELPER( temporary_table, TEMPORARY_TABLE, id ); +// +// QUERY_HELPER(customer, CUSTOMER, id, name, email, address) +// QUERY_HELPER(product, PRODUCT, id, title, description, price, category) +// QUERY_HELPER(category, CATEGORY, id, title, description) +// QUERY_HELPER(cart, CART, id, items, owner) int main() { using namespace matador::sql; diff --git a/include/matador/orm/session.hpp b/include/matador/orm/session.hpp index 9a52038..eacc8b7 100644 --- a/include/matador/orm/session.hpp +++ b/include/matador/orm/session.hpp @@ -7,6 +7,7 @@ #include "matador/query/criteria.hpp" #include "matador/query/query.hpp" #include "matador/query/generator.hpp" +#include "matador/query/schema.hpp" #include "matador/sql/connection.hpp" #include "matador/sql/connection_pool.hpp" @@ -15,7 +16,6 @@ #include "matador/sql/statement_cache.hpp" #include "matador/object/object_ptr.hpp" -#include "matador/object/repository.hpp" #include @@ -71,20 +71,13 @@ public: } template - void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) { - - } + void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {} template - void on_has_many(const char * /*id*/, ContainerType &, const char *join_column, const utils::foreign_attributes &attr) { - } + void on_has_many(const char * /*id*/, ContainerType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {} template - void on_has_many_to_many(const char *id, ContainerType &/*cont*/, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr) { - - } + void on_has_many_to_many(const char * /*id*/, ContainerType &/*cont*/, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {} template - void on_has_many_to_many(const char *id, ContainerType &/*cont*/, const utils::foreign_attributes &attr) { - - } + void on_has_many_to_many(const char * /*id*/, ContainerType &/*cont*/, const utils::foreign_attributes &/*attr*/) {} private: const std::unordered_map &statements_per_column_; @@ -151,7 +144,7 @@ private: mutable sql::statement_cache cache_; const sql::dialect &dialect_; - std::unique_ptr schema_; + std::unique_ptr schema_; mutable std::unordered_map> prototypes_; }; @@ -167,7 +160,7 @@ utils::result session::attach( const std::string& table_name template utils::result, utils::error> session::insert(Type *obj) { - auto info = schema_->info(); + auto info = schema_->repo().info(); if (!info) { return utils::failure(info.err()); } @@ -240,14 +233,14 @@ private: template utils::result, utils::error> session::update( const object::object_ptr& obj ) { - auto info = schema_->info(); + auto info = schema_->repo().info(); if (!info) { return utils::failure(info.err()); } using namespace matador::utils; using namespace matador::query; - const auto col = column(info.value().get().primary_key_attribute()->name()); + const auto col = table_column(info.value().get().primary_key_attribute()->name()); auto res = matador::query::query::update(info->get().name()) .set(generator::column_value_pairs()) .where(col == _) @@ -266,14 +259,14 @@ utils::result, utils::error> session::update( const obj template utils::result session::remove( const object::object_ptr& obj ) { - auto info = schema_->info(); + auto info = schema_->repo().info(); if (!info) { return utils::failure(info.err()); } using namespace matador::utils; using namespace matador::query; - const auto col = column(info.value().get().primary_key_attribute()->name()); + const auto col = table_column(info.value().get().primary_key_attribute()->name()); auto res = matador::query::query::remove() .from( info->get().name() ) .where(col == _) @@ -291,22 +284,24 @@ utils::result session::remove( const object::object_ptr utils::result, utils::error> session::find(const PrimaryKeyType& pk) { - auto info = schema_->info(); - if (!info) { + const auto it = schema_->find(typeid(Type)); + if (it == schema_->end()) { return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type.")); } - if (!info.value().get().has_primary_key()) { + const auto& info = it->second.node().info(); + // if (!info) { + // return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type.")); + // } + if (!info.has_primary_key()) { return utils::failure(make_error(error_code::NoPrimaryKey, "Type hasn't primary key.")); } - const auto& type_info = info.value().get(); - session_query_builder eqb(*schema_, *this); - const query::column col(std::make_shared(type_info.name()), type_info.primary_key_attribute()->name()); + const query::table_column c(&it->second.table(),info.primary_key_attribute()->name()); using namespace matador::query; - auto data = eqb.build(col == utils::_); + auto data = eqb.build(c == utils::_); if (!data.is_ok()) { - return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + type_info.name() + ".")); + return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info.name() + ".")); } auto res = build_select_query(data.release()).prepare(*this); @@ -316,14 +311,14 @@ utils::result, utils::error> session::find(const Primar } auto stmt_result = res->bind(0, const_cast(pk)).template fetch_one(); if (stmt_result && !stmt_result.value()) { - return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + type_info.name() + " with primary key " + std::to_string(pk) + ".")); + return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + info.name() + " with primary key " + std::to_string(pk) + ".")); } return utils::ok(object::object_ptr{ stmt_result->release() }); } template utils::result, utils::error> session::find(query::criteria_ptr clause) { - auto info = schema_->info(); + auto info = schema_->repo().info(); if (!info) { return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type.")); } @@ -344,7 +339,7 @@ utils::result, utils::error> session::find(query::criter template utils::result session::drop_table() { - auto info = schema_->info(); + auto info = schema_->repo().info(); if (info) { return drop_table(info->get().name()); } diff --git a/include/matador/orm/session_query_builder.hpp b/include/matador/orm/session_query_builder.hpp index d3b8bb7..5114ca8 100644 --- a/include/matador/orm/session_query_builder.hpp +++ b/include/matador/orm/session_query_builder.hpp @@ -26,7 +26,7 @@ namespace matador::orm { struct entity_query_data { const query::table* root_table{nullptr}; std::string pk_column_name{}; - std::vector columns{}; + std::vector columns{}; std::unordered_map lazy_loading_statements{}; std::vector joins{}; query::criteria_ptr where_clause{}; @@ -144,8 +144,8 @@ public: } append_join( - query::column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, - query::column{&next->second, join_column} + query::table_column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, + query::table_column{&next->second, join_column} ); @@ -210,12 +210,12 @@ public: } append_join( - query::column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, - query::column{&relation->second, join_column} + query::table_column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, + query::table_column{&relation->second, join_column} ); append_join( - query::column{&relation->second, inverse_join_column}, - query::column{&next->second, result->second.node().info().primary_key_attribute()->name()} + query::table_column{&relation->second, inverse_join_column}, + query::table_column{&next->second, result->second.node().info().primary_key_attribute()->name()} ); } @@ -257,12 +257,12 @@ public: const auto join_columns = join_columns_collector_.collect(); append_join( - query::column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, - query::column{&relation->second, join_columns.inverse_join_column} + query::table_column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, + query::table_column{&relation->second, join_columns.inverse_join_column} ); append_join( - query::column{&relation->second, join_columns.join_column}, - query::column{&next->second, result->second.node().info().primary_key_attribute()->name()} + query::table_column{&relation->second, join_columns.join_column}, + query::table_column{&next->second, result->second.node().info().primary_key_attribute()->name()} ); } @@ -272,7 +272,7 @@ private: void push(const std::string &column_name); static std::string build_alias(char prefix, unsigned int count); [[nodiscard]] bool is_root_entity() const; - void append_join(const query::column &left, const query::column &right); + void append_join(const query::table_column &left, const query::table_column &right); private: struct table_info { @@ -317,8 +317,8 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u table_info_stack_.pop(); append_join( - query::column{&table_info_stack_.top().table, id}, - query::column{&next->second, info.primary_key_attribute()->name()} + query::table_column{&table_info_stack_.top().table, id}, + query::table_column{&next->second, info.primary_key_attribute()->name()} ); } else { push(id); @@ -327,7 +327,7 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u // create select query auto result = matador::query::query::select(generator::columns(schema_, generator::column_generator_options::ForceLazy)) .from(foreign_table) - .where(column(&foreign_table, info.primary_key_attribute()->name(), "") == _) + .where(table_column(&foreign_table, info.primary_key_attribute()->name(), "") == _) .prepare(executor_); if (!result) { throw query_builder_exception(query_build_error::QueryError, result.release_error()); diff --git a/include/matador/query/builder.hpp b/include/matador/query/builder.hpp index 9906f6e..755d722 100644 --- a/include/matador/query/builder.hpp +++ b/include/matador/query/builder.hpp @@ -1,8 +1,8 @@ #ifndef MATADOR_BUILDER_HPP #define MATADOR_BUILDER_HPP -#include "matador/query/column.hpp" -#include "matador/query/constraint.hpp" +#include "matador/query/table_column.hpp" +#include "matador/query/table_constraint.hpp" #include "matador/query/table.hpp" #include "matador/utils/basic_types.hpp" @@ -65,7 +65,7 @@ public: explicit column_builder(std::string column_name, utils::basic_type type, size_t size = 0); // ReSharper disable once CppNonExplicitConversionOperator - operator column() const; // NOLINT(*-explicit-constructor) + operator table_column() const; // NOLINT(*-explicit-constructor) column_builder& not_null(); column_builder& primary_key(); @@ -97,7 +97,7 @@ public: constraint_builder& references(std::string table, std::string column); // ReSharper disable once CppNonExplicitConversionOperator - operator class constraint() const; // NOLINT(*-explicit-constructor) + operator table_constraint() const; // NOLINT(*-explicit-constructor) private: std::string constraint_name_; diff --git a/include/matador/query/criteria/abstract_column_criteria.hpp b/include/matador/query/criteria/abstract_column_criteria.hpp index e34be18..1947f5c 100644 --- a/include/matador/query/criteria/abstract_column_criteria.hpp +++ b/include/matador/query/criteria/abstract_column_criteria.hpp @@ -3,19 +3,19 @@ #include "matador/query/criteria/abstract_criteria.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" namespace matador::query { class abstract_column_criteria : public abstract_criteria { public: abstract_column_criteria() = delete; - explicit abstract_column_criteria(const class column& col); + explicit abstract_column_criteria(const table_column& col); - [[nodiscard]] const class column& col() const; + [[nodiscard]] const table_column& col() const; protected: - class column column_; + table_column column_; }; } diff --git a/include/matador/query/criteria/between_criteria.hpp b/include/matador/query/criteria/between_criteria.hpp index 46c17a1..c8f2aed 100644 --- a/include/matador/query/criteria/between_criteria.hpp +++ b/include/matador/query/criteria/between_criteria.hpp @@ -9,8 +9,8 @@ namespace matador::query { class between_criteria final : public abstract_column_criteria { public: between_criteria() = delete; - between_criteria(const class column& col, int64_t min, int64_t max); - between_criteria(const class column& col, utils::placeholder min, utils::placeholder max); + between_criteria(const table_column& col, int64_t min, int64_t max); + between_criteria(const table_column& col, utils::placeholder min, utils::placeholder max); void accept(criteria_visitor& visitor) const override; diff --git a/include/matador/query/criteria/binary_criteria.hpp b/include/matador/query/criteria/binary_criteria.hpp index 91ebe17..d8d7b35 100644 --- a/include/matador/query/criteria/binary_criteria.hpp +++ b/include/matador/query/criteria/binary_criteria.hpp @@ -4,7 +4,7 @@ #include "matador/query/criteria/abstract_column_criteria.hpp" #include "matador/query/criteria/criteria_utils.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" namespace matador::query { enum class binary_operator { @@ -19,7 +19,7 @@ enum class binary_operator { class binary_criteria final : public abstract_column_criteria { public: binary_criteria() = delete; - binary_criteria(const class column& col, binary_operator operand, criteria_value value); + binary_criteria(const table_column& col, binary_operator operand, criteria_value value); void accept( criteria_visitor& visitor ) const override; @@ -34,18 +34,18 @@ private: class binary_column_criteria final : public abstract_criteria { public: binary_column_criteria() = delete; - binary_column_criteria(const class column& left_column, binary_operator operand, const class column& right_column); + binary_column_criteria(const table_column& left_column, binary_operator operand, const table_column& right_column); void accept(criteria_visitor& visitor) const override; - [[nodiscard]] const class column& left_column() const; + [[nodiscard]] const table_column& left_column() const; [[nodiscard]] binary_operator operand() const; - [[nodiscard]] const class column& right_column() const; + [[nodiscard]] const table_column& right_column() const; private: - class column left_column_; + table_column left_column_; binary_operator operator_{}; - class column right_column_; + table_column right_column_; }; } #endif //CRITERIA_BINARY_CRITERIA_NODE_HPP \ No newline at end of file diff --git a/include/matador/query/criteria/collection_criteria.hpp b/include/matador/query/criteria/collection_criteria.hpp index c112a4e..54e01ad 100644 --- a/include/matador/query/criteria/collection_criteria.hpp +++ b/include/matador/query/criteria/collection_criteria.hpp @@ -8,7 +8,7 @@ #include "matador/sql/query_context.hpp" namespace matador::query { -class column; +class table_column; enum class collection_operator { In, @@ -38,8 +38,8 @@ public: * @param operand_ Operator to use * @param values List of values */ - collection_criteria(const class column& col, collection_operator operand_, std::vector values); - collection_criteria(const class column& col, collection_operator operand_, std::initializer_list values); + collection_criteria(const table_column& col, collection_operator operand_, std::vector values); + collection_criteria(const table_column& col, collection_operator operand_, std::initializer_list values); void accept(criteria_visitor& visitor) const override; @@ -54,7 +54,7 @@ private: class collection_query_criteria final : public abstract_column_criteria { public: collection_query_criteria() = delete; - collection_query_criteria(const class column& col, collection_operator operand_, sql::query_context ctx); + collection_query_criteria(const table_column& col, collection_operator operand_, sql::query_context ctx); void accept(criteria_visitor& visitor) const override; diff --git a/include/matador/query/criteria/criteria_operators.hpp b/include/matador/query/criteria/criteria_operators.hpp index 23c1957..aa08db4 100644 --- a/include/matador/query/criteria/criteria_operators.hpp +++ b/include/matador/query/criteria/criteria_operators.hpp @@ -11,51 +11,51 @@ namespace matador::sql { struct query_context; } namespace matador::query { -class column; +class table_column; template -criteria_ptr operator==(const class column &col, Type val) { +criteria_ptr operator==(const table_column &col, Type val) { return std::make_unique(col, binary_operator::EQUALS, utils::value(val)); } template -criteria_ptr operator!=(const class column &col, Type val) { +criteria_ptr operator!=(const table_column &col, Type val) { return std::make_unique(col, binary_operator::NOT_EQUALS, utils::value(val)); } template -criteria_ptr operator>(const class column &col, Type val) { +criteria_ptr operator>(const table_column &col, Type val) { return std::make_unique(col, binary_operator::GREATER_THAN, utils::value(val)); } template -criteria_ptr operator>=(const class column &col, Type val) { +criteria_ptr operator>=(const table_column &col, Type val) { return std::make_unique(col, binary_operator::GREATER_THAN_OR_EQUAL, utils::value(val)); } template -criteria_ptr operator<(const class column &col, Type val) { +criteria_ptr operator<(const table_column &col, Type val) { return std::make_unique(col, binary_operator::LESS_THAN, utils::value(val)); } template -criteria_ptr operator<=(const class column &col, Type val) { +criteria_ptr operator<=(const table_column &col, Type val) { return std::make_unique(col, binary_operator::LESS_THAN_OR_EQUAL, utils::value(val)); } -criteria_ptr operator==(const class column &col_left, const class column &col_right); -criteria_ptr operator!=(const class column &col_left, const class column &col_right); -criteria_ptr operator>(const class column &col_left, const class column &col_right); -criteria_ptr operator>=(const class column &col_left, const class column &col_right); -criteria_ptr operator<(const class column &col_left, const class column &col_right); -criteria_ptr operator<=(const class column &col_left, const class column &col_right); +criteria_ptr operator==(const table_column &col_left, const table_column &col_right); +criteria_ptr operator!=(const table_column &col_left, const table_column &col_right); +criteria_ptr operator>(const table_column &col_left, const table_column &col_right); +criteria_ptr operator>=(const table_column &col_left, const table_column &col_right); +criteria_ptr operator<(const table_column &col_left, const table_column &col_right); +criteria_ptr operator<=(const table_column &col_left, const table_column &col_right); -criteria_ptr operator==(const class column &col, utils::placeholder p); -criteria_ptr operator!=(const class column &col, utils::placeholder p); -criteria_ptr operator>(const class column &col, utils::placeholder p); -criteria_ptr operator>=(const class column &col, utils::placeholder p); -criteria_ptr operator<(const class column &col, utils::placeholder p); -criteria_ptr operator<=(const class column &col, utils::placeholder p); +criteria_ptr operator==(const table_column &col, utils::placeholder p); +criteria_ptr operator!=(const table_column &col, utils::placeholder p); +criteria_ptr operator>(const table_column &col, utils::placeholder p); +criteria_ptr operator>=(const table_column &col, utils::placeholder p); +criteria_ptr operator<(const table_column &col, utils::placeholder p); +criteria_ptr operator<=(const table_column &col, utils::placeholder p); criteria_ptr operator&&(criteria_ptr left, criteria_ptr right); @@ -64,7 +64,7 @@ criteria_ptr operator||(criteria_ptr left, criteria_ptr right); criteria_ptr operator!(criteria_ptr clause); template < class Type > -criteria_ptr in(const class column &col, std::initializer_list args) { +criteria_ptr in(const table_column &col, std::initializer_list args) { std::vector values; for ( auto &&arg : args ) { values.emplace_back(utils::value{std::move(arg)}); @@ -73,12 +73,12 @@ criteria_ptr in(const class column &col, std::initializer_list args) { } template <> -criteria_ptr in(const class column &col, std::initializer_list args); +criteria_ptr in(const table_column &col, std::initializer_list args); -criteria_ptr in(const class column &col, sql::query_context &&ctx); +criteria_ptr in(const table_column &col, sql::query_context &&ctx); template < class Type > -criteria_ptr out(const class column &col, std::initializer_list args) { +criteria_ptr out(const table_column &col, std::initializer_list args) { std::vector values; for ( auto &&arg : args ) { values.emplace_back(utils::value{std::move(arg)}); @@ -87,14 +87,14 @@ criteria_ptr out(const class column &col, std::initializer_list args) { } template <> -criteria_ptr out(const class column &col, std::initializer_list args); +criteria_ptr out(const table_column &col, std::initializer_list args); -criteria_ptr out(const class column &col, sql::query_context &&ctx); +criteria_ptr out(const table_column &col, sql::query_context &&ctx); -criteria_ptr between(const class column &col, int64_t min, int64_t max); -criteria_ptr between(const class column &col, utils::placeholder min, utils::placeholder max); +criteria_ptr between(const table_column &col, int64_t min, int64_t max); +criteria_ptr between(const table_column &col, utils::placeholder min, utils::placeholder max); -criteria_ptr like(const class column &col, const std::string &pattern); +criteria_ptr like(const table_column &col, const std::string &pattern); } #endif //CRITERIA_CRITERIA_OPERATORS_HPP \ No newline at end of file diff --git a/include/matador/query/criteria/like_criteria.hpp b/include/matador/query/criteria/like_criteria.hpp index ed09560..fa1d4b5 100644 --- a/include/matador/query/criteria/like_criteria.hpp +++ b/include/matador/query/criteria/like_criteria.hpp @@ -4,12 +4,12 @@ #include "matador/query/criteria/abstract_column_criteria.hpp" namespace matador::query { -class column; +class table_column; class like_criteria final : public abstract_column_criteria { public: like_criteria() = delete; - like_criteria(const class column& col, std::string pattern); + like_criteria(const table_column& col, std::string pattern); void accept(criteria_visitor &visitor) const override; diff --git a/include/matador/query/generator.hpp b/include/matador/query/generator.hpp index f2d2114..2e2a90d 100644 --- a/include/matador/query/generator.hpp +++ b/include/matador/query/generator.hpp @@ -50,13 +50,13 @@ public: column_generator_options options = default_column_generator_options); template< class Type > - std::vector generate() { + std::vector generate() { Type obj; return generate(obj); } template< class Type > - std::vector generate(const Type &obj) { + std::vector generate(const Type &obj) { result_.clear(); access::process(*this, obj); @@ -146,7 +146,7 @@ private: private: std::optional> repo_; - std::vector result_; + std::vector result_; std::stack> table_stack_; std::unordered_set seen_tables; int column_index{0}; @@ -293,7 +293,7 @@ std::vector column_value_pairs() { } template -std::vector columns(const schema &repo, +std::vector columns(const schema &repo, const std::string &table_name = "", const column_generator_options options = default_column_generator_options) { column_generator generator(repo, table_name, options); @@ -301,7 +301,7 @@ std::vector columns(const schema &repo, } template -std::vector columns(const schema &repo, +std::vector columns(const schema &repo, const column_generator_options options) { std::string table_name; if (const auto result = repo.repo().info()) { @@ -312,7 +312,7 @@ std::vector columns(const schema &repo, } template -std::vector columns(const Type &obj, +std::vector columns(const Type &obj, const schema &repo, const std::string &table_name = "", const column_generator_options options = default_column_generator_options) { diff --git a/include/matador/query/intermediates/query_alter_table_intermediate.hpp b/include/matador/query/intermediates/query_alter_table_intermediate.hpp index acba449..0762ebf 100644 --- a/include/matador/query/intermediates/query_alter_table_intermediate.hpp +++ b/include/matador/query/intermediates/query_alter_table_intermediate.hpp @@ -3,7 +3,7 @@ #include "matador/query/intermediates/executable_query.hpp" #include "matador/query/intermediates/query_intermediate.hpp" -#include "matador/query/constraint.hpp" +#include "matador/query/table_constraint.hpp" #include "matador/object/restriction.hpp" @@ -16,21 +16,21 @@ class query_add_foreign_key_constraint_intermediate final : public query_interme public: using query_intermediate::query_intermediate; - executable_query references(const table& tab, const std::vector& columns = {}); + executable_query references(const table& tab, const std::vector& columns = {}); private: table table_; - std::vector columns_; + std::vector columns_; }; class query_add_key_constraint_intermediate final : public query_intermediate { public: using query_intermediate::query_intermediate; - [[nodiscard]] query_add_primary_key_constraint_intermediate primary_key(const column& col) const; - [[nodiscard]] query_add_primary_key_constraint_intermediate primary_keys(const std::vector& columns) const; - [[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_key(const column& col) const; - [[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_keys(const std::vector& columns) const; + [[nodiscard]] query_add_primary_key_constraint_intermediate primary_key(const table_column& col) const; + [[nodiscard]] query_add_primary_key_constraint_intermediate primary_keys(const std::vector& columns) const; + [[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_key(const table_column& col) const; + [[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_keys(const std::vector& columns) const; }; class query_alter_table_intermediate final : public query_intermediate { diff --git a/include/matador/query/intermediates/query_create_intermediate.hpp b/include/matador/query/intermediates/query_create_intermediate.hpp index 5eea57e..7ecb866 100644 --- a/include/matador/query/intermediates/query_create_intermediate.hpp +++ b/include/matador/query/intermediates/query_create_intermediate.hpp @@ -5,7 +5,7 @@ #include "matador/query/intermediates/executable_query.hpp" -#include "matador/query/constraint.hpp" +#include "matador/query/table_constraint.hpp" #include "matador/object/attribute.hpp" #include "matador/object/restriction.hpp" @@ -20,8 +20,8 @@ public: 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); + executable_query constraints(std::initializer_list constraints); + executable_query constraints(const std::list &restrictions); }; class query_create_table_intermediate : public query_intermediate { @@ -30,8 +30,8 @@ public: 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); + query_create_table_columns_intermediate columns(std::initializer_list columns); + query_create_table_columns_intermediate columns(const std::list &columns); }; class query_create_intermediate : public query_intermediate { diff --git a/include/matador/query/intermediates/query_execute_where_intermediate.hpp b/include/matador/query/intermediates/query_execute_where_intermediate.hpp index 9f53f7c..c1c10a7 100644 --- a/include/matador/query/intermediates/query_execute_where_intermediate.hpp +++ b/include/matador/query/intermediates/query_execute_where_intermediate.hpp @@ -14,7 +14,7 @@ public: using executable_query::executable_query; query_execute_limit_intermediate limit(size_t limit); - query_execute_order_by_intermediate order_by(const column &col); + query_execute_order_by_intermediate order_by(const table_column &col); }; } diff --git a/include/matador/query/intermediates/query_from_intermediate.hpp b/include/matador/query/intermediates/query_from_intermediate.hpp index b43e6ce..440831d 100644 --- a/include/matador/query/intermediates/query_from_intermediate.hpp +++ b/include/matador/query/intermediates/query_from_intermediate.hpp @@ -25,8 +25,8 @@ public: // return where_clause(std::make_unique(std::move(cond))); // } query_where_intermediate where(std::unique_ptr &&cond); - query_group_by_intermediate group_by(const column &col); - query_order_by_intermediate order_by(const column &col); + query_group_by_intermediate group_by(const table_column &col); + query_order_by_intermediate order_by(const table_column &col); private: query_where_intermediate where_clause(std::unique_ptr &&cond); diff --git a/include/matador/query/intermediates/query_group_by_intermediate.hpp b/include/matador/query/intermediates/query_group_by_intermediate.hpp index 5756745..9986235 100644 --- a/include/matador/query/intermediates/query_group_by_intermediate.hpp +++ b/include/matador/query/intermediates/query_group_by_intermediate.hpp @@ -12,7 +12,7 @@ class query_group_by_intermediate : public fetchable_query public: using fetchable_query::fetchable_query; - query_order_by_intermediate order_by(const column &col); + query_order_by_intermediate order_by(const table_column &col); }; } diff --git a/include/matador/query/intermediates/query_insert_intermediate.hpp b/include/matador/query/intermediates/query_insert_intermediate.hpp index 424552f..42ab85e 100644 --- a/include/matador/query/intermediates/query_insert_intermediate.hpp +++ b/include/matador/query/intermediates/query_insert_intermediate.hpp @@ -16,8 +16,8 @@ public: query_into_intermediate into(const table &tab, const schema &scm) { return into(tab, generator::columns(scm)); } - query_into_intermediate into(const table &tab, std::initializer_list columns); - query_into_intermediate into(const table &tab, std::vector &&columns); + query_into_intermediate into(const table &tab, std::initializer_list columns); + query_into_intermediate into(const table &tab, std::vector &&columns); query_into_intermediate into(const table &tab, const std::vector &column_names); query_into_intermediate into(const table &tab); }; diff --git a/include/matador/query/intermediates/query_select_intermediate.hpp b/include/matador/query/intermediates/query_select_intermediate.hpp index 58b10df..d697b0f 100644 --- a/include/matador/query/intermediates/query_select_intermediate.hpp +++ b/include/matador/query/intermediates/query_select_intermediate.hpp @@ -10,7 +10,7 @@ class query_from_intermediate; class query_select_intermediate : public query_intermediate { public: - explicit query_select_intermediate(const std::vector& columns); + explicit query_select_intermediate(const std::vector& columns); query_from_intermediate from(const table& t); }; diff --git a/include/matador/query/intermediates/query_where_intermediate.hpp b/include/matador/query/intermediates/query_where_intermediate.hpp index 97d20fe..be32629 100644 --- a/include/matador/query/intermediates/query_where_intermediate.hpp +++ b/include/matador/query/intermediates/query_where_intermediate.hpp @@ -13,8 +13,8 @@ class query_where_intermediate : public fetchable_query public: using fetchable_query::fetchable_query; - query_group_by_intermediate group_by(const column &col); - query_order_by_intermediate order_by(const column &col); + query_group_by_intermediate group_by(const table_column &col); + query_order_by_intermediate order_by(const table_column &col); }; } diff --git a/include/matador/query/internal/column_value_pair.hpp b/include/matador/query/internal/column_value_pair.hpp index 7674a7e..18d15ac 100644 --- a/include/matador/query/internal/column_value_pair.hpp +++ b/include/matador/query/internal/column_value_pair.hpp @@ -1,7 +1,7 @@ #ifndef QUERY_KEY_VALUE_PAIR_HPP #define QUERY_KEY_VALUE_PAIR_HPP -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include "matador/utils/placeholder.hpp" #include "matador/utils/types.hpp" @@ -10,7 +10,7 @@ namespace matador::query::internal { class column_value_pair { public: - column_value_pair(const column &col, utils::database_type value); + column_value_pair(const table_column &col, utils::database_type value); column_value_pair(std::string name, utils::database_type value); column_value_pair(const char *name, utils::database_type value); column_value_pair(const char *name, utils::placeholder p); @@ -18,11 +18,11 @@ public: friend bool operator==(const column_value_pair &lhs, const column_value_pair &rhs); friend bool operator!=(const column_value_pair &lhs, const column_value_pair &rhs); - [[nodiscard]] const column& col() const; + [[nodiscard]] const table_column& col() const; [[nodiscard]] const std::variant& value() const; private: - column column_; + table_column column_; std::variant value_; }; diff --git a/include/matador/query/internal/query_parts.hpp b/include/matador/query/internal/query_parts.hpp index 9724e77..1810c48 100644 --- a/include/matador/query/internal/query_parts.hpp +++ b/include/matador/query/internal/query_parts.hpp @@ -6,8 +6,8 @@ #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_column.hpp" +#include "matador/query/table_constraint.hpp" #include "matador/query/table.hpp" #include "matador/utils/placeholder.hpp" @@ -50,12 +50,12 @@ private: class query_add_constraint_part_by_constraint final : public query_part { public: - explicit query_add_constraint_part_by_constraint(const constraint& co); + explicit query_add_constraint_part_by_constraint(const table_constraint& co); void accept(query_part_visitor &visitor) override; - [[nodiscard]] const class constraint& constraint() const; + [[nodiscard]] const table_constraint& constraint() const; private: - class constraint constraint_; + table_constraint constraint_; }; class query_drop_key_constraint_part_by_name final : public query_part { @@ -70,45 +70,45 @@ private: class query_drop_key_constraint_part_by_constraint final : public query_part { public: - explicit query_drop_key_constraint_part_by_constraint(const constraint& co); + explicit query_drop_key_constraint_part_by_constraint(const table_constraint& co); void accept(query_part_visitor &visitor) override; - [[nodiscard]] const class constraint& constraint() const; + [[nodiscard]] const table_constraint& constraint() const; private: - class constraint constraint_; + table_constraint constraint_; }; class query_add_foreign_key_constraint_part final : public query_part { public: - explicit query_add_foreign_key_constraint_part( const std::vector& columns); + explicit query_add_foreign_key_constraint_part( const std::vector& columns); void accept(query_part_visitor &visitor) override; - [[nodiscard]] const std::vector& columns() const; + [[nodiscard]] const std::vector& columns() const; private: - std::vector columns_; + std::vector columns_; }; class query_add_foreign_key_reference_part final : public query_part { public: - explicit query_add_foreign_key_reference_part(class table tab, const std::vector& columns); + explicit query_add_foreign_key_reference_part(class table tab, const std::vector& columns); void accept(query_part_visitor &visitor) override; [[nodiscard]] const class table& table() const; - [[nodiscard]] const std::vector& columns() const; + [[nodiscard]] const std::vector& columns() const; private: query::table table_; - std::vector columns_; + std::vector columns_; }; class query_add_primary_key_constraint_part final : public query_part { public: - explicit query_add_primary_key_constraint_part( const std::vector& columns); + explicit query_add_primary_key_constraint_part( const std::vector& columns); void accept(query_part_visitor &visitor) override; - [[nodiscard]] const std::vector& columns() const; + [[nodiscard]] const std::vector& columns() const; private: - std::vector columns_; + std::vector columns_; }; /** @@ -117,13 +117,13 @@ private: class query_select_part final : public query_part { public: - explicit query_select_part(std::vector columns); + explicit query_select_part(std::vector columns); void accept(query_part_visitor &visitor) override; - [[nodiscard]] const std::vector& columns() const; + [[nodiscard]] const std::vector& columns() const; private: - std::vector columns_; + std::vector columns_; }; /** @@ -205,29 +205,29 @@ protected: class query_group_by_part final : public query_part { public: - explicit query_group_by_part(class column col); + explicit query_group_by_part(class table_column col); - [[nodiscard]] const class column& column() const; + [[nodiscard]] const table_column& column() const; private: void accept(query_part_visitor &visitor) override; private: - class column column_; + table_column column_; }; class query_order_by_part final : public query_part { public: - explicit query_order_by_part(class column col); + explicit query_order_by_part(class table_column col); - [[nodiscard]] const class column& column() const; + [[nodiscard]] const table_column& column() const; private: void accept(query_part_visitor &visitor) override; private: - class column column_; + table_column column_; }; class query_order_by_asc_part final : public query_part @@ -288,17 +288,17 @@ private: class query_into_part final : public query_part { public: - query_into_part(class table tab, std::vector columns); + query_into_part(class table tab, std::vector columns); [[nodiscard]] const class table& table() const; - [[nodiscard]] const std::vector& columns() const; + [[nodiscard]] const std::vector& columns() const; private: void accept(query_part_visitor &visitor) override; private: class table table_; - std::vector columns_; + std::vector columns_; }; /** * Represents the SQL VALUES part @@ -393,28 +393,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/query.hpp b/include/matador/query/query.hpp index b079821..b40eeb6 100644 --- a/include/matador/query/query.hpp +++ b/include/matador/query/query.hpp @@ -11,10 +11,10 @@ class connection; } namespace matador::query { -column alias(const std::string &column, const std::string &as); -column alias(column &&col, const std::string &as); -column count(const std::string &column); -column count_all(); +table_column alias(const std::string &column, const std::string &as); +table_column alias(table_column &&col, const std::string &as); +table_column count(const std::string &column); +table_column count_all(); class query { @@ -22,10 +22,10 @@ public: [[nodiscard]] static query_create_intermediate create(); [[nodiscard]] static query_drop_intermediate drop(); [[nodiscard]] static query_select_intermediate select(); - [[nodiscard]] static query_select_intermediate select(std::initializer_list columns); - [[nodiscard]] static query_select_intermediate select(const std::vector& columns); + [[nodiscard]] static query_select_intermediate select(std::initializer_list columns); + [[nodiscard]] static query_select_intermediate select(const std::vector& columns); [[nodiscard]] static query_select_intermediate select(const std::vector &column_names); - [[nodiscard]] static query_select_intermediate select(std::vector columns, std::initializer_list additional_columns); + [[nodiscard]] static query_select_intermediate select(std::vector columns, std::initializer_list additional_columns); template [[nodiscard]] static query_select_intermediate select(const schema &scm) { return select(generator::columns(scm)); diff --git a/include/matador/query/query_compiler.hpp b/include/matador/query/query_compiler.hpp index 7441071..ce885b4 100644 --- a/include/matador/query/query_compiler.hpp +++ b/include/matador/query/query_compiler.hpp @@ -22,6 +22,8 @@ namespace internal { struct basic_type_to_string_visitor; } +class table_constraint; + struct query_data; struct value_visitor; @@ -77,9 +79,9 @@ protected: static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const table& t); static std::string determine_value(value_visitor &visitor, const std::variant &val); - std::string build_add_constraint_string(const class constraint& c) const; - std::string build_drop_constraint_string(const class constraint& c) const; - static std::string build_constraint_name(const class constraint& c); + [[nodiscard]] std::string build_add_constraint_string(const table_constraint& c) const; + [[nodiscard]] std::string build_drop_constraint_string(const table_constraint& c) const; + static std::string build_constraint_name(const table_constraint& c); protected: const query_data *data_{}; diff --git a/include/matador/query/query_utils.hpp b/include/matador/query/query_utils.hpp index c6cb9da..681e125 100644 --- a/include/matador/query/query_utils.hpp +++ b/include/matador/query/query_utils.hpp @@ -10,9 +10,9 @@ namespace matador::sql { class dialect; } namespace matador::query { -class column; +class table_column; -[[nodiscard]] std::string prepare_identifier(const sql::dialect& d, const column &col); -[[nodiscard]] std::string prepare_criteria(const sql::dialect& d, const column &col); +[[nodiscard]] std::string prepare_identifier(const sql::dialect& d, const table_column &col); +[[nodiscard]] std::string prepare_criteria(const sql::dialect& d, const table_column &col); } #endif //MATADOR_QUERY_UTILS_HPP \ No newline at end of file diff --git a/include/matador/query/table.hpp b/include/matador/query/table.hpp index 2528089..35eb3ae 100644 --- a/include/matador/query/table.hpp +++ b/include/matador/query/table.hpp @@ -1,7 +1,7 @@ #ifndef QUERY_TABLE_HPP #define QUERY_TABLE_HPP -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include #include @@ -14,7 +14,7 @@ public: table() = default; table(const char *name); // NOLINT(*-explicit-constructor) table(const std::string& name); // NOLINT(*-explicit-constructor) - table(const std::string& name, const std::vector& columns); + table(const std::string& name, const std::vector& columns); table(const table& other); table& operator=(const table& other); table(table&& other) noexcept; @@ -27,30 +27,30 @@ public: [[nodiscard]] const std::string& table_name() const; [[nodiscard]] const std::string& name() const; - [[nodiscard]] const std::vector& columns() const; + [[nodiscard]] const std::vector& columns() const; [[nodiscard]] bool has_alias() const; // ReSharper disable once CppNonExplicitConversionOperator - operator const std::vector&() const; // NOLINT(*-explicit-constructor) + operator const std::vector&() const; // NOLINT(*-explicit-constructor) - const class column* operator[](const std::string& column_name) const; - static const class column* column_by_name(const table &tab, const std::string& column_name); + const table_column* operator[](const std::string& column_name) const; + static const table_column* column_by_name(const table &tab, const std::string& column_name); protected: - static const column& create_column(class table& tab, const std::string& name); + static const table_column& create_column(class table& tab, const std::string& name); private: - table(std::string name, std::string alias, const std::vector& columns); + table(std::string name, std::string alias, const std::vector& columns); private: - friend class column; + friend table_column; std::string name_; 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/query/column.hpp b/include/matador/query/table_column.hpp similarity index 57% rename from include/matador/query/column.hpp rename to include/matador/query/table_column.hpp index 4901199..c420062 100644 --- a/include/matador/query/column.hpp +++ b/include/matador/query/table_column.hpp @@ -15,22 +15,22 @@ namespace matador::query { class table; // ReSharper disable CppNonExplicitConvertingConstructor -class column { +class table_column { public: - column(const char *name); // NOLINT(*-explicit-constructor) - column(std::string name); // NOLINT(*-explicit-constructor) - column(std::string name, std::string alias); - column(sql::sql_function_t func, std::string name); - column(const class table* tab, std::string name); - column(const class table* tab, std::string name, std::string alias); - column(const class table* tab, std::string name, utils::basic_type type, const utils::field_attributes& attributes); - column(const class table*, std::string name, std::string alias, utils::basic_type type, const utils::field_attributes& attributes); - column& operator=(const column& other); - column(const column& other); + table_column(const char *name); // NOLINT(*-explicit-constructor) + table_column(std::string name); // NOLINT(*-explicit-constructor) + table_column(std::string name, std::string alias); + table_column(sql::sql_function_t func, std::string name); + table_column(const class table* tab, std::string name); + table_column(const class table* tab, std::string name, std::string alias); + table_column(const class table* tab, std::string name, utils::basic_type type, const utils::field_attributes& attributes); + table_column(const class table*, std::string name, std::string alias, utils::basic_type type, const utils::field_attributes& attributes); + table_column& operator=(const table_column& other); + table_column(const table_column& other); - [[nodiscard]] bool equals(const column &x) const; + [[nodiscard]] bool equals(const table_column &x) const; - column as(std::string a); + table_column as(std::string a); [[nodiscard]] const std::string& name() const; [[nodiscard]] const std::string& alias() const; @@ -60,7 +60,7 @@ private: sql::sql_function_t function_{sql::sql_function_t::None}; }; -column operator ""_col(const char *name, size_t len); +table_column operator ""_col(const char *name, size_t len); } #endif //QUERY_COLUMN_HPP diff --git a/include/matador/query/constraint.hpp b/include/matador/query/table_constraint.hpp similarity index 62% rename from include/matador/query/constraint.hpp rename to include/matador/query/table_constraint.hpp index b4a6c8a..6148769 100644 --- a/include/matador/query/constraint.hpp +++ b/include/matador/query/table_constraint.hpp @@ -8,12 +8,12 @@ enum class constraints : unsigned char; } namespace matador::query { -class constraint { +class table_constraint { public: - constraint() = default; - constraint(std::string column_name, std::string table_name, utils::constraints type); - constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column); - constraint(std::string name, std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column); + table_constraint() = default; + table_constraint(std::string column_name, std::string table_name, utils::constraints type); + table_constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column); + table_constraint(std::string name, std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column); [[nodiscard]] std::string name() const; [[nodiscard]] std::string column_name() const; diff --git a/include/matador/sql/query_macro.hpp b/include/matador/sql/query_macro.hpp index 9f7b9b6..0b0e93d 100644 --- a/include/matador/sql/query_macro.hpp +++ b/include/matador/sql/query_macro.hpp @@ -4,7 +4,7 @@ #include "matador/utils/macro_map.hpp" #include "matador/query/table.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include #include diff --git a/source/orm/CMakeLists.txt b/source/orm/CMakeLists.txt index 7efb5b5..d7c7e45 100644 --- a/source/orm/CMakeLists.txt +++ b/source/orm/CMakeLists.txt @@ -4,8 +4,6 @@ add_library(matador-orm STATIC ../../include/matador/orm/session_query_builder.hpp ../../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 @@ -59,6 +57,8 @@ add_library(matador-orm STATIC ../../include/matador/query/query_utils.hpp ../../include/matador/query/schema.hpp ../../include/matador/query/table.hpp + ../../include/matador/query/table_column.hpp + ../../include/matador/query/table_constraint.hpp ../../include/matador/query/value_extractor.hpp ../../include/matador/sql/abstract_sql_logger.hpp ../../include/matador/sql/backend_provider.hpp @@ -90,8 +90,6 @@ add_library(matador-orm STATIC orm/session_query_builder.cpp 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 @@ -140,6 +138,8 @@ add_library(matador-orm STATIC query/query_utils.cpp query/schema.cpp query/table.cpp + query/table_column.cpp + query/table_constraint.cpp query/value_extractor.cpp sql/backend_provider.cpp sql/connection.cpp diff --git a/source/orm/orm/session.cpp b/source/orm/orm/session.cpp index 3ebbcfe..4e95e82 100644 --- a/source/orm/orm/session.cpp +++ b/source/orm/orm/session.cpp @@ -15,7 +15,7 @@ utils::error make_error(const error_code ec, const std::string &msg) { session::session(session_context&& ctx) : cache_(ctx.bus, ctx.pool, ctx.cache_size) , dialect_(sql::backend_provider::instance().connection_dialect(ctx.pool.info().type)) -, schema_(std::make_unique(dialect_.default_schema_name())) { +, schema_(std::make_unique(dialect_.default_schema_name())) { } utils::result session::create_schema() const { @@ -49,7 +49,7 @@ utils::result session::create_schema() const { // } auto c = cache_.pool().acquire(); - for (const auto &node: *schema_) { + for (const auto &node: schema_->repo()) { auto ctx = query::query::create() .table(node->name()) .columns(node->info().attributes()) @@ -62,7 +62,7 @@ utils::result session::create_schema() const { } // create table constraints - for (const auto &node: *schema_) { + for (const auto &node: schema_->repo()) { for (const auto& cons : node->info().constraints()) { auto ctx = build_add_constraint_context(node->name(), cons, c); @@ -95,7 +95,7 @@ sql::query_context session::build_add_constraint_context(const std::string& tabl utils::result session::drop_schema() const { auto c = cache_.pool().acquire(); // drop table constraints - for (const auto &node: *schema_) { + for (const auto &node: schema_->repo()) { for (const auto& cons : node->info().constraints()) { auto ctx = query::query::alter() .table(node->name()) @@ -110,7 +110,7 @@ utils::result session::drop_schema() const { } // drop table - for (const auto &node: *schema_) { + for (const auto &node: schema_->repo()) { auto ctx = query::query::drop() .table(node->name()) .compile(*c); @@ -191,7 +191,7 @@ const class sql::dialect &session::dialect() const { } void session::dump_schema(std::ostream &os) const { - schema_->dump(os); + schema_->repo().dump(os); } utils::result, utils::error> session::fetch(const sql::query_context& ctx) const { diff --git a/source/orm/orm/session_query_builder.cpp b/source/orm/orm/session_query_builder.cpp index cb24acf..6f4490a 100644 --- a/source/orm/orm/session_query_builder.cpp +++ b/source/orm/orm/session_query_builder.cpp @@ -47,7 +47,7 @@ void criteria_transformer::update_criteria_column(const query::abstract_column_c return; } - const_cast(node.col()).table(&it->second); + const_cast(node.col()).table(&it->second); } void session_query_builder::on_revision(const char *id, uint64_t &/*rev*/) { @@ -73,7 +73,7 @@ std::string session_query_builder::build_alias(const char prefix, const unsigned return table_info_stack_.size() == 1; } -void session_query_builder::append_join(const query::column &left, const query::column &right) { +void session_query_builder::append_join(const query::table_column &left, const query::table_column &right) { using namespace matador::query; entity_query_data_.joins.push_back({ right.table(), diff --git a/source/orm/query/builder.cpp b/source/orm/query/builder.cpp index 80e70e5..50e072c 100644 --- a/source/orm/query/builder.cpp +++ b/source/orm/query/builder.cpp @@ -7,7 +7,7 @@ column_builder::column_builder(std::string column_name, const utils::basic_type , type_(type) , size_(size) {} -column_builder::operator class query::column() const { +column_builder::operator class query::table_column() const { return {nullptr, column_name_, type_, {size_, constraints_}}; } @@ -57,7 +57,7 @@ constraint_builder& constraint_builder::references( std::string table, std::stri return *this; } -constraint_builder::operator class constraint() const { +constraint_builder::operator table_constraint() const { return {constraint_name_, column_name_, ref_table_name_, type_, ref_table_name_, ref_column_name_}; } diff --git a/source/orm/query/criteria/abstract_column_criteria.cpp b/source/orm/query/criteria/abstract_column_criteria.cpp index 54aad33..0e1926b 100644 --- a/source/orm/query/criteria/abstract_column_criteria.cpp +++ b/source/orm/query/criteria/abstract_column_criteria.cpp @@ -1,10 +1,10 @@ #include "matador/query/criteria/abstract_column_criteria.hpp" namespace matador::query { -abstract_column_criteria::abstract_column_criteria(const class column& col) +abstract_column_criteria::abstract_column_criteria(const table_column& col) : column_(col) {} -const column& abstract_column_criteria::col() const { +const table_column& abstract_column_criteria::col() const { return column_; } } \ No newline at end of file diff --git a/source/orm/query/criteria/between_criteria.cpp b/source/orm/query/criteria/between_criteria.cpp index 599a5c5..94e1c22 100644 --- a/source/orm/query/criteria/between_criteria.cpp +++ b/source/orm/query/criteria/between_criteria.cpp @@ -3,13 +3,13 @@ #include "matador/query/criteria/criteria_visitor.hpp" namespace matador::query{ -between_criteria::between_criteria(const class column& col, const int64_t min, const int64_t max) +between_criteria::between_criteria(const table_column& col, const int64_t min, const int64_t max) : abstract_column_criteria(col) , min_(utils::value{min}) , max_(utils::value{max}) {} -between_criteria::between_criteria(const class column& col, utils::placeholder min, utils::placeholder max) +between_criteria::between_criteria(const table_column& col, utils::placeholder min, utils::placeholder max) : abstract_column_criteria(col) , min_(min) , max_(max) diff --git a/source/orm/query/criteria/binary_criteria.cpp b/source/orm/query/criteria/binary_criteria.cpp index 4204ea7..6bc9b7f 100644 --- a/source/orm/query/criteria/binary_criteria.cpp +++ b/source/orm/query/criteria/binary_criteria.cpp @@ -3,7 +3,7 @@ #include "matador/query/criteria/criteria_visitor.hpp" namespace matador::query { -binary_criteria::binary_criteria(const class column& col, const binary_operator operand, criteria_value value) +binary_criteria::binary_criteria(const table_column& col, const binary_operator operand, criteria_value value) : abstract_column_criteria(col) , operator_(operand) , value_(std::move(value)) @@ -21,7 +21,7 @@ const criteria_value& binary_criteria::value() const { return value_; } -binary_column_criteria::binary_column_criteria(const class column& left_column, const binary_operator operand, const class column& right_column) +binary_column_criteria::binary_column_criteria(const table_column& left_column, const binary_operator operand, const table_column& right_column) : left_column_(left_column) , operator_(operand) , right_column_(right_column){} @@ -30,7 +30,7 @@ void binary_column_criteria::accept(criteria_visitor& visitor) const { visitor.visit(*this); } -const class column& binary_column_criteria::left_column() const { +const table_column& binary_column_criteria::left_column() const { return left_column_; } @@ -38,7 +38,7 @@ binary_operator binary_column_criteria::operand() const { return operator_; } -const class column& binary_column_criteria::right_column() const { +const table_column& binary_column_criteria::right_column() const { return right_column_; } } diff --git a/source/orm/query/criteria/collection_criteria.cpp b/source/orm/query/criteria/collection_criteria.cpp index 4ba08f7..b28be1f 100644 --- a/source/orm/query/criteria/collection_criteria.cpp +++ b/source/orm/query/criteria/collection_criteria.cpp @@ -1,16 +1,16 @@ #include "matador/query/criteria/collection_criteria.hpp" #include "matador/query/criteria/criteria_visitor.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" namespace matador::query { -collection_criteria::collection_criteria(const class column& col, const collection_operator operand_, std::vector values ) +collection_criteria::collection_criteria(const table_column& col, const collection_operator operand_, std::vector values ) : abstract_column_criteria(col) , operand_(operand_) , values_(std::move(values)) {} -collection_criteria::collection_criteria(const class column& col, const collection_operator operand_, const std::initializer_list values ) +collection_criteria::collection_criteria(const table_column& col, const collection_operator operand_, const std::initializer_list values ) : abstract_column_criteria(col) , operand_(operand_) , values_(values) @@ -28,7 +28,7 @@ const std::vector& collection_criteria::values() const { return values_; } -collection_query_criteria::collection_query_criteria(const class column& col, collection_operator operand_, sql::query_context ctx) +collection_query_criteria::collection_query_criteria(const table_column& col, collection_operator operand_, sql::query_context ctx) : abstract_column_criteria(col) , operand_(operand_) , query_context_(std::move(ctx)){ diff --git a/source/orm/query/criteria/criteria_operators.cpp b/source/orm/query/criteria/criteria_operators.cpp index c648055..143621a 100644 --- a/source/orm/query/criteria/criteria_operators.cpp +++ b/source/orm/query/criteria/criteria_operators.cpp @@ -6,51 +6,51 @@ #include "matador/query/criteria/not_criteria.hpp" namespace matador::query { -criteria_ptr operator==(const column &col, utils::placeholder p) { +criteria_ptr operator==(const table_column &col, utils::placeholder p) { return std::make_unique(col, binary_operator::EQUALS, p); } -criteria_ptr operator!=(const column &col, utils::placeholder p) { +criteria_ptr operator!=(const table_column &col, utils::placeholder p) { return std::make_unique(col, binary_operator::NOT_EQUALS, p); } -criteria_ptr operator>(const column &col, utils::placeholder p) { +criteria_ptr operator>(const table_column &col, utils::placeholder p) { return std::make_unique(col, binary_operator::GREATER_THAN, p); } -criteria_ptr operator>=(const column &col, utils::placeholder p) { +criteria_ptr operator>=(const table_column &col, utils::placeholder p) { return std::make_unique(col, binary_operator::GREATER_THAN_OR_EQUAL, p); } -criteria_ptr operator<(const column &col, utils::placeholder p) { +criteria_ptr operator<(const table_column &col, utils::placeholder p) { return std::make_unique(col, binary_operator::LESS_THAN, p); } -criteria_ptr operator<=(const column &col, utils::placeholder p) { +criteria_ptr operator<=(const table_column &col, utils::placeholder p) { return std::make_unique(col, binary_operator::LESS_THAN_OR_EQUAL, p); } -criteria_ptr operator==( const column& col_left, const column& col_right ) { +criteria_ptr operator==( const table_column& col_left, const table_column& col_right ) { return std::make_unique(col_left, binary_operator::EQUALS, col_right); } -criteria_ptr operator!=( const column& col_left, const column& col_right ) { +criteria_ptr operator!=( const table_column& col_left, const table_column& col_right ) { return std::make_unique(col_left, binary_operator::NOT_EQUALS, col_right); } -criteria_ptr operator>( const column& col_left, const column& col_right ) { +criteria_ptr operator>( const table_column& col_left, const table_column& col_right ) { return std::make_unique(col_left, binary_operator::GREATER_THAN, col_right); } -criteria_ptr operator>=( const column& col_left, const column& col_right ) { +criteria_ptr operator>=( const table_column& col_left, const table_column& col_right ) { return std::make_unique(col_left, binary_operator::GREATER_THAN_OR_EQUAL, col_right); } -criteria_ptr operator<( const column& col_left, const column& col_right ) { +criteria_ptr operator<( const table_column& col_left, const table_column& col_right ) { return std::make_unique(col_left, binary_operator::LESS_THAN, col_right); } -criteria_ptr operator<=( const column& col_left, const column& col_right ) { +criteria_ptr operator<=( const table_column& col_left, const table_column& col_right ) { return std::make_unique(col_left, binary_operator::LESS_THAN_OR_EQUAL, col_right); } @@ -67,7 +67,7 @@ criteria_ptr operator!(criteria_ptr clause) { } template <> -criteria_ptr in(const column &col, const std::initializer_list args) { +criteria_ptr in(const table_column &col, const std::initializer_list args) { std::vector values; for ( auto &&arg : args ) { values.emplace_back(arg); @@ -75,12 +75,12 @@ criteria_ptr in(const column &col, const std::initializer_list(col, collection_operator::In, std::move(values)); } -criteria_ptr in(const column &col, sql::query_context &&ctx) { +criteria_ptr in(const table_column &col, sql::query_context &&ctx) { return std::make_unique(col, collection_operator::In, std::move(ctx)); } template <> -criteria_ptr out(const column &col, const std::initializer_list args) { +criteria_ptr out(const table_column &col, const std::initializer_list args) { std::vector values; for ( auto &&arg : args ) { values.emplace_back(arg); @@ -88,19 +88,19 @@ criteria_ptr out(const column &col, const std::initializer_list(col, collection_operator::Out, values); } -criteria_ptr out(const column &col, sql::query_context &&ctx) { +criteria_ptr out(const table_column &col, sql::query_context &&ctx) { return std::make_unique(col, collection_operator::In, std::move(ctx)); } -criteria_ptr between(const column &col, const int64_t min, const int64_t max) { +criteria_ptr between(const table_column &col, const int64_t min, const int64_t max) { return std::make_unique(col, min, max); } -criteria_ptr between(const column &col, utils::placeholder min, utils::placeholder max) { +criteria_ptr between(const table_column &col, utils::placeholder min, utils::placeholder max) { return std::make_unique(col, min, max); } -criteria_ptr like(const column &col, const std::string &pattern) { +criteria_ptr like(const table_column &col, const std::string &pattern) { return std::make_unique(col, pattern); } } diff --git a/source/orm/query/criteria/like_criteria.cpp b/source/orm/query/criteria/like_criteria.cpp index 12a535d..4bf6248 100644 --- a/source/orm/query/criteria/like_criteria.cpp +++ b/source/orm/query/criteria/like_criteria.cpp @@ -1,10 +1,10 @@ #include "matador/query/criteria/like_criteria.hpp" #include "matador/query/criteria/criteria_visitor.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" namespace matador::query { -like_criteria::like_criteria(const class column& col, std::string pattern) +like_criteria::like_criteria(const table_column& col, std::string pattern) : abstract_column_criteria(col) , pattern_(std::move(pattern)){} diff --git a/source/orm/query/intermediates/query_alter_table_intermediate.cpp b/source/orm/query/intermediates/query_alter_table_intermediate.cpp index aa3781e..ebe0423 100644 --- a/source/orm/query/intermediates/query_alter_table_intermediate.cpp +++ b/source/orm/query/intermediates/query_alter_table_intermediate.cpp @@ -4,27 +4,27 @@ #include "matador/query/internal/query_parts.hpp" namespace matador::query { -executable_query query_add_foreign_key_constraint_intermediate::references( const table& tab, const std::vector& columns) { +executable_query query_add_foreign_key_constraint_intermediate::references( const table& tab, const std::vector& columns) { context_->parts.push_back(std::make_unique(tab, columns)); return {context_}; } -query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const column& col) const { +query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const table_column& col) const { return primary_keys({col}); } -query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector& columns) const { +query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector& columns) const { context_->parts.push_back(std::make_unique(columns)); return {context_}; } -query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const column& col) const { +query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const table_column& col) const { return foreign_keys({col}); } -query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys(const std::vector& columns) const { +query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys(const std::vector& columns) const { context_->parts.push_back(std::make_unique(columns)); return {context_}; @@ -32,7 +32,7 @@ query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermedi executable_query query_alter_table_intermediate::add_constraint(const object::restriction &rest) { context_->parts.push_back(std::make_unique( - constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()} + table_constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()} )); return {context_}; @@ -46,7 +46,7 @@ query_add_key_constraint_intermediate query_alter_table_intermediate::add_constr executable_query query_alter_table_intermediate::drop_constraint(const object::restriction &rest) { context_->parts.push_back(std::make_unique( - constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()}) + table_constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()}) ); return {context_}; } diff --git a/source/orm/query/intermediates/query_create_intermediate.cpp b/source/orm/query/intermediates/query_create_intermediate.cpp index 94898f4..8cab626 100644 --- a/source/orm/query/intermediates/query_create_intermediate.cpp +++ b/source/orm/query/intermediates/query_create_intermediate.cpp @@ -2,7 +2,7 @@ #include "matador/query/internal/query_parts.hpp" -#include "matador/query/constraint.hpp" +#include "matador/query/table_constraint.hpp" #include "matador/object/object.hpp" @@ -28,17 +28,17 @@ executable_query query_create_table_columns_intermediate::constraints(const std: return this->constraints(std::list(constraints)); } -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(const std::list& constraints){ context_->parts.push_back(std::make_unique(constraints)); return {context_}; } executable_query query_create_table_columns_intermediate::constraints(const std::list& restrictions) { - std::list constraints; + std::list constraints; for (const auto& restr : restrictions) { if (restr.is_primary_key_constraint()) { constraints.emplace_back(restr.column_name(), restr.owner()->name(), restr.attribute().attributes().options()); @@ -57,7 +57,7 @@ query_create_table_columns_intermediate query_create_table_intermediate::columns } query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list& attributes) { - std::list columns; + std::list columns; for (const auto& attr : attributes) { auto options = attr.attributes().options(); if (!attr.is_nullable()) { @@ -70,11 +70,11 @@ query_create_table_columns_intermediate query_create_table_intermediate::columns return {context_}; } -query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list columns) { +query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list columns) { return this->columns(std::list(columns)); } -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& columns) { context_->parts.push_back(std::make_unique(columns)); return {context_}; diff --git a/source/orm/query/intermediates/query_execute_where_intermediate.cpp b/source/orm/query/intermediates/query_execute_where_intermediate.cpp index a778ec2..d4acca7 100644 --- a/source/orm/query/intermediates/query_execute_where_intermediate.cpp +++ b/source/orm/query/intermediates/query_execute_where_intermediate.cpp @@ -12,7 +12,7 @@ query_execute_limit_intermediate query_execute_where_intermediate::limit(size_t return {context_}; } -query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const column &col) { +query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const table_column &col) { context_->parts.push_back(std::make_unique(col)); return {context_}; } diff --git a/source/orm/query/intermediates/query_from_intermediate.cpp b/source/orm/query/intermediates/query_from_intermediate.cpp index 2342e2b..2f8f783 100644 --- a/source/orm/query/intermediates/query_from_intermediate.cpp +++ b/source/orm/query/intermediates/query_from_intermediate.cpp @@ -38,12 +38,12 @@ query_where_intermediate query_from_intermediate::where_clause(std::unique_ptrparts.push_back(std::make_unique(col)); return {context_}; } -query_order_by_intermediate query_from_intermediate::order_by(const column &col) { +query_order_by_intermediate query_from_intermediate::order_by(const table_column &col) { context_->parts.push_back(std::make_unique(col)); return {context_}; } diff --git a/source/orm/query/intermediates/query_group_by_intermediate.cpp b/source/orm/query/intermediates/query_group_by_intermediate.cpp index 4dd64c8..375565d 100644 --- a/source/orm/query/intermediates/query_group_by_intermediate.cpp +++ b/source/orm/query/intermediates/query_group_by_intermediate.cpp @@ -5,7 +5,7 @@ namespace matador::query { -query_order_by_intermediate query_group_by_intermediate::order_by(const column &col) { +query_order_by_intermediate query_group_by_intermediate::order_by(const table_column &col) { context_->parts.push_back(std::make_unique(col)); return {context_}; } diff --git a/source/orm/query/intermediates/query_insert_intermediate.cpp b/source/orm/query/intermediates/query_insert_intermediate.cpp index b6d574a..54d57ad 100644 --- a/source/orm/query/intermediates/query_insert_intermediate.cpp +++ b/source/orm/query/intermediates/query_insert_intermediate.cpp @@ -10,17 +10,17 @@ query_insert_intermediate::query_insert_intermediate() { context_->parts.push_back(std::make_unique()); } -query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list columns) { - return into(tab, std::move(std::vector{columns})); +query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list columns) { + return into(tab, std::move(std::vector{columns})); } -query_into_intermediate query_insert_intermediate::into(const table &tab, std::vector &&columns) { +query_into_intermediate query_insert_intermediate::into(const table &tab, std::vector &&columns) { context_->parts.push_back(std::make_unique(tab, columns)); return {context_}; } query_into_intermediate query_insert_intermediate::into(const table &tab, const std::vector &column_names) { - std::vector columns; + std::vector columns; columns.reserve(column_names.size()); for (const auto &col_name : column_names) { columns.emplace_back(col_name); diff --git a/source/orm/query/intermediates/query_select_intermediate.cpp b/source/orm/query/intermediates/query_select_intermediate.cpp index e35752f..80ea5db 100644 --- a/source/orm/query/intermediates/query_select_intermediate.cpp +++ b/source/orm/query/intermediates/query_select_intermediate.cpp @@ -6,7 +6,7 @@ namespace matador::query { -query_select_intermediate::query_select_intermediate(const std::vector& columns) { +query_select_intermediate::query_select_intermediate(const std::vector& columns) { context_->parts.push_back(std::make_unique(columns)); } diff --git a/source/orm/query/intermediates/query_where_intermediate.cpp b/source/orm/query/intermediates/query_where_intermediate.cpp index 91743b5..e2a60ae 100644 --- a/source/orm/query/intermediates/query_where_intermediate.cpp +++ b/source/orm/query/intermediates/query_where_intermediate.cpp @@ -6,12 +6,12 @@ namespace matador::query { -query_group_by_intermediate query_where_intermediate::group_by(const column &col) { +query_group_by_intermediate query_where_intermediate::group_by(const table_column &col) { context_->parts.push_back(std::make_unique(col)); return {context_}; } -query_order_by_intermediate query_where_intermediate::order_by(const column &col) { +query_order_by_intermediate query_where_intermediate::order_by(const table_column &col) { context_->parts.push_back(std::make_unique(col)); return {context_}; } diff --git a/source/orm/query/internal/column_value_pair.cpp b/source/orm/query/internal/column_value_pair.cpp index 360314d..67275ba 100644 --- a/source/orm/query/internal/column_value_pair.cpp +++ b/source/orm/query/internal/column_value_pair.cpp @@ -9,7 +9,7 @@ column_value_pair::column_value_pair(std::string name, utils::database_type valu , value_(std::move(value)) { } -column_value_pair::column_value_pair(const column &col, utils::database_type value) +column_value_pair::column_value_pair(const table_column &col, utils::database_type value) : column_(col) , value_(std::move(value)) { } @@ -23,7 +23,7 @@ column_value_pair::column_value_pair( const char* name, utils::placeholder p ) : column_(name) , value_(p) {} -const column &column_value_pair::col() const { +const table_column &column_value_pair::col() const { return column_; } diff --git a/source/orm/query/internal/query_parts.cpp b/source/orm/query/internal/query_parts.cpp index bf710c9..3fb5948 100644 --- a/source/orm/query/internal/query_parts.cpp +++ b/source/orm/query/internal/query_parts.cpp @@ -34,7 +34,7 @@ const std::string& query_add_key_constraint_part::name() const { return name_; } -query_add_constraint_part_by_constraint::query_add_constraint_part_by_constraint(const query::constraint &co) +query_add_constraint_part_by_constraint::query_add_constraint_part_by_constraint(const query::table_constraint &co) : query_part(sql::dialect_token::AddConstraint) , constraint_(co) {} @@ -42,7 +42,7 @@ void query_add_constraint_part_by_constraint::accept(query_part_visitor &visitor visitor.visit(*this); } -const class constraint & query_add_constraint_part_by_constraint::constraint() const { +const table_constraint & query_add_constraint_part_by_constraint::constraint() const { return constraint_; } @@ -58,7 +58,7 @@ const std::string& query_drop_key_constraint_part_by_name::name() const { return name_; } -query_drop_key_constraint_part_by_constraint::query_drop_key_constraint_part_by_constraint(const class constraint &co) +query_drop_key_constraint_part_by_constraint::query_drop_key_constraint_part_by_constraint(const table_constraint &co) : query_part( sql::dialect_token::DropConstraint ) , constraint_(co) {} @@ -66,11 +66,11 @@ void query_drop_key_constraint_part_by_constraint::accept(query_part_visitor& vi visitor.visit(*this); } -const class constraint& query_drop_key_constraint_part_by_constraint::constraint() const { +const table_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& columns) +query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector& columns) : query_part(sql::dialect_token::ForeignKey) , columns_(columns) {} @@ -78,11 +78,11 @@ void query_add_foreign_key_constraint_part::accept( query_part_visitor& visitor visitor.visit(*this); } -const std::vector& query_add_foreign_key_constraint_part::columns() const { +const std::vector& query_add_foreign_key_constraint_part::columns() const { return columns_; } -query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector& columns) +query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector& columns) : query_part(sql::dialect_token::References) , table_(std::move(tab)) , columns_(columns) {} @@ -95,11 +95,11 @@ const table& query_add_foreign_key_reference_part::table() const { return table_; } -const std::vector& query_add_foreign_key_reference_part::columns() const { +const std::vector& query_add_foreign_key_reference_part::columns() const { return columns_; } -query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector& columns) +query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector& columns) : query_part(sql::dialect_token::PrimaryKey) , columns_(columns) {} @@ -107,11 +107,11 @@ void query_add_primary_key_constraint_part::accept( query_part_visitor& visitor visitor.visit(*this); } -const std::vector& query_add_primary_key_constraint_part::columns() const { +const std::vector& query_add_primary_key_constraint_part::columns() const { return columns_; } -query_select_part::query_select_part(std::vector columns) +query_select_part::query_select_part(std::vector columns) : query_part(sql::dialect_token::Select) , columns_(std::move(columns)) {} @@ -120,7 +120,7 @@ void query_select_part::accept(query_part_visitor &visitor) visitor.visit(*this); } -const std::vector& query_select_part::columns() const +const std::vector& query_select_part::columns() const { return columns_; } @@ -185,12 +185,12 @@ query_table_name_part::query_table_name_part(const sql::dialect_token token, std : query_part(token) , table_name_(std::move(table_name)) {} -query_group_by_part::query_group_by_part(class column col) +query_group_by_part::query_group_by_part(class table_column col) : query_part(sql::dialect_token::GroupBy) , column_(std::move(col)) {} -const column &query_group_by_part::column() const +const table_column &query_group_by_part::column() const { return column_; } @@ -200,12 +200,12 @@ void query_group_by_part::accept(query_part_visitor &visitor) visitor.visit(*this); } -query_order_by_part::query_order_by_part(class column col) +query_order_by_part::query_order_by_part(class table_column col) : query_part(sql::dialect_token::OrderBy) , column_(std::move(col)) {} -const column &query_order_by_part::column() const +const table_column &query_order_by_part::column() const { return column_; } @@ -269,7 +269,7 @@ void query_insert_part::accept(query_part_visitor &visitor) visitor.visit(*this); } -query_into_part::query_into_part(class table tab, std::vector columns) +query_into_part::query_into_part(class table tab, std::vector columns) : query_part(sql::dialect_token::Insert) , table_(std::move(tab)) , columns_(std::move(columns)) {} @@ -279,7 +279,7 @@ const table &query_into_part::table() const return table_; } -const std::vector &query_into_part::columns() const +const std::vector &query_into_part::columns() const { return columns_; } @@ -375,11 +375,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_; } @@ -387,11 +387,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.cpp b/source/orm/query/query.cpp index 5d730e9..b25772d 100644 --- a/source/orm/query/query.cpp +++ b/source/orm/query/query.cpp @@ -2,20 +2,20 @@ namespace matador::query { -column alias(const std::string &column, const std::string &as) { +table_column alias(const std::string &column, const std::string &as) { return {column, as}; } -column alias(column &&col, const std::string &as) { +table_column alias(table_column &&col, const std::string &as) { col.as(as); return std::move(col); } -column count(const std::string &column) { +table_column count(const std::string &column) { return {sql::sql_function_t::Count, column}; } -column count_all() { +table_column count_all() { return count("*"); } @@ -32,16 +32,16 @@ query_select_intermediate query::select() { return query_select_intermediate{{}}; } -query_select_intermediate query::select( const std::initializer_list columns) { - return select(std::vector{columns}); +query_select_intermediate query::select( const std::initializer_list columns) { + return select(std::vector{columns}); } -query_select_intermediate query::select(const std::vector& columns) { +query_select_intermediate query::select(const std::vector& columns) { return query_select_intermediate{columns}; } query_select_intermediate query::select(const std::vector &column_names) { - std::vector columns; + std::vector columns; columns.reserve(column_names.size()); for (const auto &col_name : column_names) { columns.emplace_back(col_name); @@ -49,7 +49,7 @@ query_select_intermediate query::select(const std::vector &column_n return select(columns); } -query_select_intermediate query::select(std::vector columns, const std::initializer_list additional_columns) { +query_select_intermediate query::select(std::vector columns, const std::initializer_list additional_columns) { for (const auto &col : additional_columns) { columns.push_back(col); } diff --git a/source/orm/query/query_compiler.cpp b/source/orm/query/query_compiler.cpp index 0328e01..b3a66c6 100644 --- a/source/orm/query/query_compiler.cpp +++ b/source/orm/query/query_compiler.cpp @@ -4,8 +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/table_constraint.hpp" +#include "matador/query/table_column.hpp" #include "matador/query/internal/basic_type_to_string_visitor.hpp" #include "matador/query/internal/query_parts.hpp" @@ -37,7 +37,7 @@ sql::query_context query_compiler::compile(const query_data &data, return {query_}; } -std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const column &col) { +std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const table_column &col) { if (col.is_function()) { ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.name()); ctx.prototype.back().change_type(utils::basic_type::Int32); @@ -301,8 +301,8 @@ void query_compiler::visit(internal::query_create_part &/*create_part*/) query_.sql = dialect_->create(); } -std::string build_create_column(const column &col, const sql::dialect &d); -std::string build_constraint(const class constraint &cons, const sql::dialect &d); +std::string build_create_column(const table_column &col, const sql::dialect &d); +std::string build_constraint(const table_constraint &cons, const sql::dialect &d); void query_compiler::visit(internal::query_create_table_part &part) { @@ -385,7 +385,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 column &col, const sql::dialect &d) { +std::string build_create_column(const table_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()) + ")"); @@ -403,7 +403,7 @@ std::string build_create_column(const column &col, const sql::dialect &d) { return result; } -std::string build_constraint(const constraint& cons, const sql::dialect& d) { +std::string build_constraint(const table_constraint& cons, const sql::dialect& d) { std::string result; if (!cons.name().empty()) { result.append(d.constraint()).append(" ").append(cons.name()).append(" "); @@ -438,7 +438,7 @@ std::string query_compiler::build_table_name(const sql::dialect_token token, con (!t.has_alias() ? "" : " " + d.prepare_identifier_string(t.name())); } -std::string query_compiler::build_add_constraint_string(const class constraint &c) const { +std::string query_compiler::build_add_constraint_string(const table_constraint &c) const { 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(")"); @@ -450,11 +450,11 @@ std::string query_compiler::build_add_constraint_string(const class constraint & return result; } -std::string query_compiler::build_drop_constraint_string(const class constraint &c) const { +std::string query_compiler::build_drop_constraint_string(const table_constraint &c) const { return dialect_->drop_constraint() + " " + build_constraint_name(c); } -std::string query_compiler::build_constraint_name(const class constraint &c) { +std::string query_compiler::build_constraint_name(const table_constraint &c) { if (c.is_primary_key_constraint()) { return "PK_" + c.table_name(); } diff --git a/source/orm/query/query_utils.cpp b/source/orm/query/query_utils.cpp index 8836185..6544d05 100644 --- a/source/orm/query/query_utils.cpp +++ b/source/orm/query/query_utils.cpp @@ -3,7 +3,7 @@ #include "matador/query/table.hpp" namespace matador::query { -std::string prepare_identifier(const sql::dialect& d, const column& col) { +std::string prepare_identifier(const sql::dialect& d, const table_column& col) { std::string result; if (!col.is_function()) { if (col.table()) { @@ -19,7 +19,7 @@ std::string prepare_identifier(const sql::dialect& d, const column& col) { return result; } -std::string prepare_criteria(const sql::dialect& d, const column& col) { +std::string prepare_criteria(const sql::dialect& d, const table_column& col) { std::string result; if (!col.is_function()) { if (col.table()) { diff --git a/source/orm/query/schema.cpp b/source/orm/query/schema.cpp index faafa07..5eea8dd 100644 --- a/source/orm/query/schema.cpp +++ b/source/orm/query/schema.cpp @@ -252,7 +252,7 @@ sql::query_context schema::build_drop_constraint_context(const object::repositor } void schema::insert_table(const std::type_index &ti, const object::repository_node &node) { - std::vector columns; + std::vector columns; for (const auto &attr: node.info().attributes()) { columns.emplace_back(nullptr, attr.name(), attr.type(), attr.attributes()); } diff --git a/source/orm/query/table.cpp b/source/orm/query/table.cpp index a822eb5..e6e82eb 100644 --- a/source/orm/query/table.cpp +++ b/source/orm/query/table.cpp @@ -11,11 +11,11 @@ table::table(const char* name) table::table(const std::string& name) : table(name, name, {}) {} -table::table(const std::string& name, const std::vector &columns) +table::table(const std::string& name, const std::vector &columns) : table(name, name, columns) { } -table::table(std::string name, std::string alias, const std::vector &columns) +table::table(std::string name, std::string alias, const std::vector &columns) : name_(std::move(name)) , alias_(std::move(alias)) , columns_(columns) { @@ -68,7 +68,7 @@ const std::string& table::name() const { return alias_; } -const std::vector& table::columns() const { +const std::vector& table::columns() const { return columns_; } @@ -76,11 +76,11 @@ bool table::has_alias() const { return name_ != alias_; } -table::operator const std::vector&() const { +table::operator const std::vector&() const { return columns_; } -const class column* table::operator[](const std::string &column_name) const { +const table_column* table::operator[](const std::string &column_name) const { for (const auto &col : columns_) { if (col.name() == column_name) { return &col; @@ -89,7 +89,7 @@ const class column* table::operator[](const std::string &column_name) const { return nullptr; } -const class column * table::column_by_name(const table &tab, const std::string &column_name) { +const table_column * table::column_by_name(const table &tab, const std::string &column_name) { for (const auto &col : tab.columns_) { if (col.name() == column_name) { return &col; @@ -98,7 +98,7 @@ const class column * table::column_by_name(const table &tab, const std::string & return nullptr; } -const column& table::create_column(class table &tab, const std::string &name) { +const table_column& table::create_column(class table &tab, const std::string &name) { tab.columns_.emplace_back(name); tab.columns_.back().table(&tab); return tab.columns_.back(); diff --git a/source/orm/query/column.cpp b/source/orm/query/table_column.cpp similarity index 59% rename from source/orm/query/column.cpp rename to source/orm/query/table_column.cpp index bae3f45..57d3670 100644 --- a/source/orm/query/column.cpp +++ b/source/orm/query/table_column.cpp @@ -1,4 +1,4 @@ -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include "matador/query/table.hpp" @@ -7,43 +7,43 @@ namespace matador::query { -column operator ""_col(const char *name, const size_t len) { +table_column operator ""_col(const char *name, const size_t len) { const std::string str(name, len); const auto pos = str.find('.'); if (pos == std::string::npos) { - return column{str}; + return table_column{str}; } if (str.find('.', pos + 1) != std::string::npos) { throw std::invalid_argument("Invalid column name: multiple dots found"); } - return column{str.substr(pos + 1)}; + return table_column{str.substr(pos + 1)}; } -column::column(const char *name) -: column(std::string(name)) +table_column::table_column(const char *name) +: table_column(std::string(name)) {} -column::column(std::string name) +table_column::table_column(std::string name) : name_(std::move(name)) {} -column::column(std::string name, std::string alias) +table_column::table_column(std::string name, std::string alias) : name_(std::move(name)) , alias_(std::move(alias)) {} -column::column(const sql::sql_function_t func, std::string name) +table_column::table_column(const sql::sql_function_t func, std::string name) : name_(std::move(name)) , function_(func) {} -column::column(const class table* tab, std::string name) +table_column::table_column(const class table* tab, std::string name) : table_(tab) , name_(std::move(name)) {} -column::column(const class table* tab, std::string name, std::string alias) +table_column::table_column(const class table* tab, std::string name, std::string alias) : table_(tab) , name_(std::move(name)) , alias_(std::move(alias)) {} -column::column(const class table* tab, +table_column::table_column(const class table* tab, std::string name, const utils::basic_type type, const utils::field_attributes& attributes) @@ -52,7 +52,7 @@ column::column(const class table* tab, , type_(type) , attributes_(attributes) {} -column::column(const class table* tab, +table_column::table_column(const class table* tab, std::string name, std::string alias, utils::basic_type type, @@ -63,7 +63,7 @@ column::column(const class table* tab, , type_(type) , attributes_(attributes) {} -column & column::operator=(const column &other) { +table_column & table_column::operator=(const table_column &other) { if (this == &other) { return *this; } @@ -75,7 +75,7 @@ column & column::operator=(const column &other) { return *this; } -column::column(const column &other) +table_column::table_column(const table_column &other) : table_(other.table_) , name_(other.name_) , alias_(other.alias_) @@ -83,7 +83,7 @@ column::column(const column &other) , attributes_(other.attributes_) { } -bool column::equals(const column &x) const { +bool table_column::equals(const table_column &x) const { if (table_ != nullptr && x.table_ != nullptr) { return *table_ == *x.table_ && name_ == x.name_ && @@ -96,52 +96,52 @@ bool column::equals(const column &x) const { function_ == x.function_; } -column column::as(std::string a) { +table_column table_column::as(std::string a) { alias_ = std::move(a); return {table_, name_, alias_, type_, attributes_}; } -const std::string& column::name() const { +const std::string& table_column::name() const { return name_; } -const std::string& column::alias() const { +const std::string& table_column::alias() const { return alias_; } -utils::basic_type column::type() const { +utils::basic_type table_column::type() const { return type_; } -utils::field_attributes column::attributes() const { +utils::field_attributes table_column::attributes() const { return attributes_; } -bool column::is_function() const { +bool table_column::is_function() const { return function_ != sql::sql_function_t::None; } -bool column::is_nullable() const { +bool table_column::is_nullable() const { return !utils::is_constraint_set(attributes_.options(), utils::constraints::NotNull); } -sql::sql_function_t column::function() const { +sql::sql_function_t table_column::function() const { return function_; } -bool column::has_alias() const { +bool table_column::has_alias() const { return !alias_.empty(); } -const class table* column::table() const { +const class table* table_column::table() const { return table_; } -void column::table(const query::table* tab) { +void table_column::table(const query::table* tab) { table_ = tab; } -column::operator const std::string&() const { +table_column::operator const std::string&() const { return name_; } } diff --git a/source/orm/query/constraint.cpp b/source/orm/query/table_constraint.cpp similarity index 57% rename from source/orm/query/constraint.cpp rename to source/orm/query/table_constraint.cpp index 33111f5..2e49280 100644 --- a/source/orm/query/constraint.cpp +++ b/source/orm/query/table_constraint.cpp @@ -1,21 +1,21 @@ -#include "matador/query/constraint.hpp" +#include "matador/query/table_constraint.hpp" #include "matador/utils/constraints.hpp" namespace matador::query { -constraint::constraint(std::string column_name, std::string table_name, utils::constraints type) +table_constraint::table_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) +table_constraint::table_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)) {} -constraint::constraint(std::string name, +table_constraint::table_constraint(std::string name, std::string column_name, std::string table_name, utils::constraints type, @@ -28,39 +28,39 @@ constraint::constraint(std::string name, , referenced_table_(std::move(referenced_table)) , referenced_column_(std::move(referenced_column)) {} -std::string constraint::name() const { +std::string table_constraint::name() const { return name_; } -std::string constraint::column_name() const { +std::string table_constraint::column_name() const { return column_name_; } -std::string constraint::table_name() const { +std::string table_constraint::table_name() const { return table_name_; } -const utils::constraints& constraint::type() const { +const utils::constraints& table_constraint::type() const { return type_; } -bool constraint::is_primary_key_constraint() const { +bool table_constraint::is_primary_key_constraint() const { return utils::is_constraint_set(type_, utils::constraints::PrimaryKey); } -bool constraint::is_foreign_key_constraint() const { +bool table_constraint::is_foreign_key_constraint() const { return utils::is_constraint_set(type_, utils::constraints::ForeignKey); } -bool constraint::is_unique_constraint() const { +bool table_constraint::is_unique_constraint() const { return utils::is_constraint_set(type_, utils::constraints::Unique); } -const std::string& constraint::referenced_table() const { +const std::string& table_constraint::referenced_table() const { return referenced_table_; } -const std::string& constraint::referenced_column() const { +const std::string& table_constraint::referenced_column() const { return referenced_column_; } } diff --git a/test/backends/QueryRecordTest.cpp b/test/backends/QueryRecordTest.cpp index 09df1eb..04c8996 100644 --- a/test/backends/QueryRecordTest.cpp +++ b/test/backends/QueryRecordTest.cpp @@ -5,7 +5,7 @@ #include "matador/query/builder.hpp" #include "matador/query/criteria.hpp" #include "matador/query/query.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include "matador/utils/types.hpp" #include "matador/utils/string.hpp" diff --git a/test/backends/QueryStatementTests.cpp b/test/backends/QueryStatementTests.cpp index ee9b845..c6b74cd 100644 --- a/test/backends/QueryStatementTests.cpp +++ b/test/backends/QueryStatementTests.cpp @@ -4,7 +4,7 @@ #include "matador/query/criteria.hpp" #include "matador/query/query.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include "models/person.hpp" diff --git a/test/backends/QueryTest.cpp b/test/backends/QueryTest.cpp index 44c1796..6324e91 100644 --- a/test/backends/QueryTest.cpp +++ b/test/backends/QueryTest.cpp @@ -156,7 +156,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][for .and_then( [this] { return repo.attach("flight");} ); REQUIRE(result.is_ok()); - auto obj = object_generator::generate(repo, "airplane"); + auto obj = object_generator::generate(repo.repo(), "airplane"); auto res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -168,7 +168,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][for REQUIRE(db.exists("airplane")); tables_to_drop.emplace("airplane"); - obj = object_generator::generate(repo, "flight"); + obj = object_generator::generate(repo.repo(), "flight"); res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -225,7 +225,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left" .and_then( [this] { return repo.attach("flight");} ); REQUIRE(result.is_ok()); - auto obj = object_generator::generate(repo, "airplane"); + auto obj = object_generator::generate(repo.repo(), "airplane"); auto res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -237,7 +237,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left" REQUIRE(db.exists("airplane")); tables_to_drop.emplace("airplane"); - obj = object_generator::generate(repo, "flight"); + obj = object_generator::generate(repo.repo(), "flight"); res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -295,8 +295,8 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left" REQUIRE(f.value()->at(2).as() == "hans"); auto select_result = query::select({"f.id", "ap.brand", "ap.model", "f.pilot_name"}) - .from({"flight", "f"}) - .join_left({"airplane", "ap"}) + .from("flight"_tab.as("f")) + .join_left("airplane"_tab.as("ap")) .on("f.airplane_id"_col == "ap.id"_col) .order_by("f.id").asc() .fetch_all(db); @@ -321,7 +321,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single .and_then( [this] { return repo.attach("flight");} ); REQUIRE(result.is_ok()); - auto obj = object_generator::generate(repo, "airplane"); + auto obj = object_generator::generate(repo.repo(), "airplane"); auto res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -333,7 +333,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single REQUIRE(db.exists("airplane")); tables_to_drop.emplace("airplane"); - obj = object_generator::generate(repo, "flight"); + obj = object_generator::generate(repo.repo(), "flight"); res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -393,8 +393,8 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single REQUIRE(f.value()->at(2).as() == "hans"); auto select_result = query::select({"f.id", "f.airplane_id", "ap.brand", "ap.model", "f.pilot_name"}) - .from({"flight", "f"}) - .join_left({"airplane", "ap"}) + .from("flight"_tab.as("f")) + .join_left("airplane"_tab.as("ap")) .on("f.airplane_id"_col == "ap.id"_col) .where("f.id"_col == 4) .fetch_one(db); @@ -416,7 +416,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship" auto result = repo.attach("recipes") .and_then( [this] { return repo.attach("ingredients"); } ); - auto obj = object_generator::generate(repo, "recipes"); + auto obj = object_generator::generate(repo.repo(), "recipes"); auto res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -428,7 +428,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship" REQUIRE(db.exists("recipes")); tables_to_drop.emplace("recipes"); - obj = object_generator::generate(repo, "ingredients"); + obj = object_generator::generate(repo.repo(), "ingredients"); res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -440,7 +440,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship" REQUIRE(db.exists("ingredients")); tables_to_drop.emplace("ingredients"); - obj = object_generator::generate(repo, "recipe_ingredients"); + obj = object_generator::generate(repo.repo(), "recipe_ingredients"); res = query::create() .table(obj->name()) .columns(obj->attributes()) @@ -507,8 +507,8 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship" } auto select_result = query::select({"r.id", "r.name", "ri.ingredient_id"}) - .from({"recipes", "r"}) - .join_left({"recipe_ingredients", "ri"}) + .from("recipes"_tab.as("r")) + .join_left("recipe_ingredients"_tab.as("ri")) .on("r.id"_col == "ri.recipe_id"_col) .fetch_all(db); REQUIRE(select_result.is_ok()); @@ -533,9 +533,11 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship" } select_result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"}) - .from({"recipes", "r"}) - .join_left({"recipe_ingredients", "ri"}).on("r.id"_col == "ri.recipe_id"_col) - .join_left({"ingredients", "i"}).on("ri.ingredient_id"_col == "i.id"_col) + .from("recipes"_tab.as("r")) + .join_left("recipe_ingredients"_tab.as("ri")) + .on("r.id"_col == "ri.recipe_id"_col) + .join_left("ingredients"_tab.as("i")) + .on("ri.ingredient_id"_col == "i.id"_col) .fetch_all(db); REQUIRE(result.is_ok()); @@ -560,9 +562,11 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship" } select_result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"}) - .from({"recipes", "r"}) - .join_left({"recipe_ingredients", "ri"}).on("r.id"_col == "ri.recipe_id"_col) - .join_left({"ingredients", "i"}).on("ri.ingredient_id"_col == "i.id"_col) + .from("recipes"_tab.as("r")) + .join_left("recipe_ingredients"_tab.as("ri")) + .on("r.id"_col == "ri.recipe_id"_col) + .join_left("ingredients"_tab.as("i")) + .on("ri.ingredient_id"_col == "i.id"_col) .where("r.id"_col == 8) .fetch_all(db); REQUIRE(result.is_ok()); diff --git a/test/orm/orm/SessionQueryBuilderTest.cpp b/test/orm/orm/SessionQueryBuilderTest.cpp index 1a7b099..1e0d670 100644 --- a/test/orm/orm/SessionQueryBuilderTest.cpp +++ b/test/orm/orm/SessionQueryBuilderTest.cpp @@ -8,7 +8,7 @@ #include "matador/query/criteria_evaluator.hpp" #include "matador/query/query.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include "matador/query/table.hpp" #include "matador/query/schema.hpp" @@ -59,9 +59,9 @@ public: , author_id(*column_by_name(*this, "author_id")) { } - const column& id; - const column& title; - const column& author_id; + const table_column& id; + const table_column& title; + const table_column& author_id; }; book_table BOOK; @@ -92,7 +92,7 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity REQUIRE(data->joins.size() == 1); const auto flights = table("flights").as("t01"); const auto airplanes = table("airplanes").as("t02"); - const std::vector expected_columns { + const std::vector expected_columns { { &flights, "id", "c01" }, { &airplanes, "id", "c02" }, { &airplanes, "brand", "c03" }, @@ -146,7 +146,7 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent REQUIRE(data->joins.size() == 1); const auto books = table("books").as("t01"); const auto authors = table("authors").as("t02"); - const std::vector expected_columns { + const std::vector expected_columns { { &books, "id", "c01" }, { &books, "title", "c02" }, { &authors, "id", "c03" }, @@ -218,7 +218,7 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q REQUIRE(data->joins.size() == 1); const auto orders = table("orders").as("t01"); const auto order_details = table("order_details").as("t02"); - const std::vector expected_columns = { + const std::vector expected_columns = { { &orders, "order_id", "c01" }, { &orders, "order_date", "c02" }, { &orders, "required_date", "c03" }, @@ -282,7 +282,7 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e REQUIRE(data->joins.size() == 2); const auto ingredients = table("ingredients").as("t01"); const auto recipes = table("recipes").as("t03"); - const std::vector expected_columns { + const std::vector expected_columns { { &ingredients, "id", "c01" }, { &ingredients, "name", "c02" }, { &recipes, "id", "c03" }, @@ -336,7 +336,7 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par REQUIRE(data->joins.size() == 2); const auto courses = table("courses").as("t01"); const auto students = table("students").as("t03"); - const std::vector expected_columns { + const std::vector expected_columns { { &courses, "id", "c01" }, { &courses, "title", "c02" }, { &students, "id", "c03" }, @@ -386,7 +386,7 @@ TEST_CASE("Test eager relationship", "[session][eager]") { .from(*data->root_table) .join_left(data->joins) .where(std::move(data->where_clause)) - .order_by(column{data->root_table, data->pk_column_name}) + .order_by(table_column{data->root_table, data->pk_column_name}) .asc() .str(db); diff --git a/test/orm/query/GeneratorTests.cpp b/test/orm/query/GeneratorTests.cpp index ec07d07..51117cf 100644 --- a/test/orm/query/GeneratorTests.cpp +++ b/test/orm/query/GeneratorTests.cpp @@ -1,7 +1,7 @@ #include #include "matador/query/generator.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include "../../models/airplane.hpp" #include "../../models/flight.hpp" diff --git a/test/orm/query/QueryBuilderTest.cpp b/test/orm/query/QueryBuilderTest.cpp index ef5ea91..b27aa87 100644 --- a/test/orm/query/QueryBuilderTest.cpp +++ b/test/orm/query/QueryBuilderTest.cpp @@ -5,7 +5,7 @@ #include #include #include "matador/query/table.hpp" -#include "matador/query/column.hpp" +#include "matador/query/table_column.hpp" #include "matador/query/builder.hpp" #include "matador/sql/connection.hpp" @@ -249,8 +249,8 @@ TEST_CASE_METHOD(QueryFixture, "Test create, insert and select a blob column", " TEST_CASE_METHOD(QueryFixture, "Test select statement with join_left", "[query][statement][join_left]") { const auto ap = table("airplane").as("ap"); const auto f = table("flight").as("f"); - const class matador::query::column col1 = {&f, "airplane_id"}; - const class matador::query::column col2 = {&ap, "id"}; + const class matador::query::table_column col1 = {&f, "airplane_id"}; + const class matador::query::table_column col2 = {&ap, "id"}; const auto result = query::select({"f.id", "ap.brand", "f.pilot_name"}) .from(table{"flight"}.as("f")) .join_left(table{"airplane"}.as("ap")) diff --git a/test/orm/sql/ColumnGeneratorTest.cpp b/test/orm/sql/ColumnGeneratorTest.cpp index b1fc63f..193d781 100644 --- a/test/orm/sql/ColumnGeneratorTest.cpp +++ b/test/orm/sql/ColumnGeneratorTest.cpp @@ -68,7 +68,7 @@ TEST_CASE("Generate columns for object with has many relation", "[column][genera const auto order_table = table("order"); const auto order_details_table = table("order_details"); - const std::vector expected_columns = { + const std::vector expected_columns = { { &order_table, "order_id", "c01" }, { &order_table, "order_date", "c02" }, { &order_table, "required_date", "c03" }, @@ -106,7 +106,7 @@ TEST_CASE("Generate columns for object with eager foreign key relation", "[colum const auto books_table = table("books"); const auto authors_table = table("authors"); - const std::vector expected_columns { + const std::vector expected_columns { { &books_table, "id", "c01" }, { &books_table, "title", "c02" }, { &authors_table, "id", "c03" },