From 758284c2b3ce21e752b89eaeee09bbfb3d8f244e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sascha=20K=C3=BChl?= Date: Fri, 21 Nov 2025 09:22:00 +0100 Subject: [PATCH] renamed class attribute_definition to attribute --- .../postgres/include/postgres_connection.hpp | 2 +- backends/postgres/src/postgres_connection.cpp | 8 +- include/matador/object/attribute.hpp | 163 ++++++++++++++++ .../matador/object/attribute_definition.hpp | 163 ---------------- .../object/attribute_definition_generator.hpp | 26 +-- include/matador/object/basic_object_info.hpp | 14 +- include/matador/object/object_info.hpp | 6 +- include/matador/object/repository.hpp | 4 +- include/matador/object/repository_node.hpp | 2 +- include/matador/orm/schema.hpp | 2 +- include/matador/orm/session.hpp | 4 +- include/matador/query/builder.hpp | 43 +++-- .../query_create_intermediate.hpp | 4 +- .../matador/query/internal/query_parts.hpp | 8 +- include/matador/query/query_data.hpp | 4 +- include/matador/sql/connection.hpp | 4 +- .../matador/sql/interface/connection_impl.hpp | 4 +- .../sql/internal/query_result_impl.hpp | 10 +- include/matador/sql/query_context.hpp | 4 +- include/matador/sql/query_macro.hpp | 4 +- include/matador/sql/query_result.hpp | 6 +- source/core/CMakeLists.txt | 4 +- source/core/object/attribute.cpp | 178 ++++++++++++++++++ source/core/object/attribute_definition.cpp | 178 ------------------ .../object/attribute_definition_generator.cpp | 6 +- source/core/object/basic_object_info.cpp | 10 +- source/core/object/repository.cpp | 2 +- source/core/object/repository_node.cpp | 4 +- source/orm/orm/schema.cpp | 2 +- source/orm/orm/session.cpp | 4 +- .../query/intermediates/fetchable_query.cpp | 2 +- .../query_create_intermediate.cpp | 6 +- source/orm/query/internal/query_parts.cpp | 4 +- .../orm/query/internal/query_result_impl.cpp | 6 +- source/orm/query/query_compiler.cpp | 6 +- source/orm/sql/connection.cpp | 6 +- source/orm/sql/query_result.cpp | 2 +- test/backends/QueryBasicTest.cpp | 34 ++-- test/backends/QueryTest.cpp | 2 +- test/backends/StatementTest.cpp | 2 +- .../AttributeDefinitionGeneratorTest.cpp | 24 +-- test/orm/backend/test_connection.cpp | 4 +- test/orm/backend/test_connection.hpp | 2 +- test/orm/sql/ColumnTest.cpp | 8 +- 44 files changed, 490 insertions(+), 491 deletions(-) create mode 100644 include/matador/object/attribute.hpp delete mode 100644 include/matador/object/attribute_definition.hpp create mode 100644 source/core/object/attribute.cpp delete mode 100644 source/core/object/attribute_definition.cpp diff --git a/backends/postgres/include/postgres_connection.hpp b/backends/postgres/include/postgres_connection.hpp index f8c688c..57c2f2b 100644 --- a/backends/postgres/include/postgres_connection.hpp +++ b/backends/postgres/include/postgres_connection.hpp @@ -35,7 +35,7 @@ public: utils::result, utils::error> prepare(const sql::query_context &context) override; utils::result, utils::error> fetch(const sql::query_context &context) override; - utils::result, utils::error> describe(const std::string& table) override; + utils::result, utils::error> describe(const std::string& table) override; utils::result exists(const std::string &schema_name, const std::string &table_name) override; [[nodiscard]] std::string to_escaped_string( const utils::blob& value ) const override; diff --git a/backends/postgres/src/postgres_connection.cpp b/backends/postgres/src/postgres_connection.cpp index f970dd4..1061c7f 100644 --- a/backends/postgres/src/postgres_connection.cpp +++ b/backends/postgres/src/postgres_connection.cpp @@ -3,7 +3,7 @@ #include "postgres_result_reader.hpp" #include "postgres_statement.hpp" -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/sql/error_code.hpp" #include "matador/sql/record.hpp" @@ -89,7 +89,7 @@ utils::result, utils::error> postgres_co return utils::failure(make_error(sql::error_code::FETCH_FAILED, res, conn_, "Failed to fetch", context.sql)); } - std::vector prototype = context.prototype; + std::vector prototype = context.prototype; const int num_col = PQnfields(res); if (prototype.size() != static_cast(num_col)) { @@ -212,7 +212,7 @@ utils::basic_type string2type(const char *type) { } } -utils::result, utils::error> postgres_connection::describe(const std::string &table) { +utils::result, utils::error> postgres_connection::describe(const std::string &table) { const std::string stmt( "SELECT ordinal_position, column_name, udt_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_schema='public' AND table_name='" + table + "'"); @@ -224,7 +224,7 @@ utils::result, utils::error> postgres_ } postgres_result_reader reader(res); - std::vector prototype; + std::vector prototype; while (auto fetched = reader.fetch()) { if (!fetched.is_ok()) { return utils::failure(fetched.release_error()); diff --git a/include/matador/object/attribute.hpp b/include/matador/object/attribute.hpp new file mode 100644 index 0000000..a9df82a --- /dev/null +++ b/include/matador/object/attribute.hpp @@ -0,0 +1,163 @@ +#ifndef QUERY_COLUMN_DEFINITION_HPP +#define QUERY_COLUMN_DEFINITION_HPP + +#include "matador/utils/basic_types.hpp" +#include "matador/utils/default_type_traits.hpp" +#include "matador/utils/field_attributes.hpp" + +#include + +namespace matador::object { + +enum class null_option_type : uint8_t { + NULLABLE, NOT_NULL +}; + +struct attribute_options { + utils::field_attributes attributes; + null_option_type null_option{null_option_type::NOT_NULL}; + int index{-1}; +}; + +class attribute { +public: + explicit attribute(const char *name); // NOLINT(*-explicit-constructor) + explicit attribute(std::string name); // NOLINT(*-explicit-constructor) + + attribute(const attribute&) = default; + attribute& operator=(const attribute&) = default; + attribute(attribute&&) noexcept = default; + attribute& operator=(attribute&&) noexcept = default; + + attribute() = default; + attribute(std::string name, + utils::basic_type type, + const utils::field_attributes&, + null_option_type null_opt, + int index = 0); + attribute(std::string name, + utils::basic_type type, + int index, + const std::shared_ptr &ref_column, + const utils::field_attributes& attr, + null_option_type null_opt); + + attribute(std::string name, + utils::basic_type type, + const std::shared_ptr &ref_column = {}); + attribute(std::string name, + utils::basic_type type, + std::string table_name, + const attribute_options& options, + const std::shared_ptr &ref_column = {}); + + [[nodiscard]] const std::string& name() const; + void name(const std::string& n); + [[nodiscard]] std::string full_name() const; + [[nodiscard]] int index() const; + [[nodiscard]] const utils::field_attributes& attributes() const; + [[nodiscard]] utils::field_attributes& attributes(); + [[nodiscard]] bool is_nullable() const; + [[nodiscard]] utils::basic_type type() const; + [[nodiscard]] const std::string& table_name() const; + void table_name(const std::string& name); + void change_type(utils::basic_type type, const utils::field_attributes &attr = utils::null_attributes); + template < typename Type > + void change_type(const utils::field_attributes &attr = utils::null_attributes) { + type_ = utils::data_type_traits::type(attr.size()); + } + [[nodiscard]] std::shared_ptr reference_column() const; + [[nodiscard]] bool is_foreign_reference() const; + + [[nodiscard]] bool is_integer() const; + [[nodiscard]] bool is_floating_point() const; + [[nodiscard]] bool is_bool() const; + [[nodiscard]] bool is_string() const; + [[nodiscard]] bool is_varchar() const; + [[nodiscard]] bool is_date() const; + [[nodiscard]] bool is_time() const; + [[nodiscard]] bool is_blob() const; + [[nodiscard]] bool is_null() const; + + template< typename Type > + [[nodiscard]] bool is_type_of() const { + return type() == utils::data_type_traits::type(attributes().size()); + } + +private: + std::string name_; + std::string table_name_; + attribute_options options_; + utils::basic_type type_{utils::basic_type::type_null}; + + std::shared_ptr reference_column_; +}; + +/** + * User defined literal to have a shortcut creating a column object + * @param name Name of the column + * @param type + * @param attr Length of the column name + * @param null_opt + * @return A column object with a given name + */ +attribute make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr = utils::null_attributes, null_option_type null_opt = null_option_type::NOT_NULL); + +template < typename Type > +attribute make_column(const std::string &name, utils::field_attributes attr = utils::null_attributes, null_option_type null_opt = null_option_type::NOT_NULL) +{ + return make_column(name, utils::data_type_traits::type(0), attr, null_opt); +} +template <> +attribute make_column(const std::string &name, utils::field_attributes attr, null_option_type null_opt); + +template < typename Type > +attribute make_pk_column(const std::string &name, size_t size = 0) +{ + return make_column(name, { size, utils::constraints::PRIMARY_KEY }); +} + +template <> +attribute make_pk_column(const std::string &name, size_t size); + +template < typename Type > +attribute make_fk_column(const std::string &name, size_t size, const std::shared_ptr &ref_column) { + return {name, utils::data_type_traits::type(size), ref_column, { size, utils::constraints::FOREIGN_KEY }}; +} + +template < typename Type > +[[maybe_unused]] attribute make_fk_column(const std::string &name, const std::shared_ptr &ref_column) +{ + return {name, utils::data_type_traits::type(0), 0, ref_column, { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL}; +} + +template <> +[[maybe_unused]] attribute make_fk_column(const std::string &name, size_t size, const std::shared_ptr &ref_column); + +template < typename Type > +[[maybe_unused]] attribute make_fk_column(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name) { + return { + name, utils::data_type_traits::type(size), 0, + std::make_shared(ref_column_name, ref_table_name, utils::data_type_traits::type(size), utils::constraints::FOREIGN_KEY), + { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL + }; +} + +template < typename Type > +[[maybe_unused]] attribute make_fk_column(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name) { + return { + name, utils::data_type_traits::type(0), 0, + std::make_shared(ref_column_name, utils::data_type_traits::type(0), ref_table_name, attribute_options{utils::constraints::FOREIGN_KEY}), + { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL + }; +} + +template <> +[[maybe_unused]] attribute make_fk_column(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name); + +template <> +[[maybe_unused]] attribute make_fk_column(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name); + +} + +#endif //QUERY_COLUMN_DEFINITION_HPP diff --git a/include/matador/object/attribute_definition.hpp b/include/matador/object/attribute_definition.hpp deleted file mode 100644 index 880eda5..0000000 --- a/include/matador/object/attribute_definition.hpp +++ /dev/null @@ -1,163 +0,0 @@ -#ifndef QUERY_COLUMN_DEFINITION_HPP -#define QUERY_COLUMN_DEFINITION_HPP - -#include "matador/utils/basic_types.hpp" -#include "matador/utils/default_type_traits.hpp" -#include "matador/utils/field_attributes.hpp" - -#include - -namespace matador::object { - -enum class null_option_type : uint8_t { - NULLABLE, NOT_NULL -}; - -struct attribute_options { - utils::field_attributes attributes; - null_option_type null_option{null_option_type::NOT_NULL}; - int index{-1}; -}; - -class attribute_definition { -public: - explicit attribute_definition(const char *name); // NOLINT(*-explicit-constructor) - explicit attribute_definition(std::string name); // NOLINT(*-explicit-constructor) - - attribute_definition(const attribute_definition&) = default; - attribute_definition& operator=(const attribute_definition&) = default; - attribute_definition(attribute_definition&&) noexcept = default; - attribute_definition& operator=(attribute_definition&&) noexcept = default; - - attribute_definition() = default; - attribute_definition(std::string name, - utils::basic_type type, - const utils::field_attributes&, - null_option_type null_opt, - int index = 0); - attribute_definition(std::string name, - utils::basic_type type, - int index, - const std::shared_ptr &ref_column, - const utils::field_attributes& attr, - null_option_type null_opt); - - attribute_definition(std::string name, - utils::basic_type type, - const std::shared_ptr &ref_column = {}); - attribute_definition(std::string name, - utils::basic_type type, - std::string table_name, - const attribute_options& options, - const std::shared_ptr &ref_column = {}); - - [[nodiscard]] const std::string& name() const; - void name(const std::string& n); - [[nodiscard]] std::string full_name() const; - [[nodiscard]] int index() const; - [[nodiscard]] const utils::field_attributes& attributes() const; - [[nodiscard]] utils::field_attributes& attributes(); - [[nodiscard]] bool is_nullable() const; - [[nodiscard]] utils::basic_type type() const; - [[nodiscard]] const std::string& table_name() const; - void table_name(const std::string& name); - void change_type(utils::basic_type type, const utils::field_attributes &attr = utils::null_attributes); - template < typename Type > - void change_type(const utils::field_attributes &attr = utils::null_attributes) { - type_ = utils::data_type_traits::type(attr.size()); - } - [[nodiscard]] std::shared_ptr reference_column() const; - [[nodiscard]] bool is_foreign_reference() const; - - [[nodiscard]] bool is_integer() const; - [[nodiscard]] bool is_floating_point() const; - [[nodiscard]] bool is_bool() const; - [[nodiscard]] bool is_string() const; - [[nodiscard]] bool is_varchar() const; - [[nodiscard]] bool is_date() const; - [[nodiscard]] bool is_time() const; - [[nodiscard]] bool is_blob() const; - [[nodiscard]] bool is_null() const; - - template< typename Type > - [[nodiscard]] bool is_type_of() const { - return type() == utils::data_type_traits::type(attributes().size()); - } - -private: - std::string name_; - std::string table_name_; - attribute_options options_; - utils::basic_type type_{utils::basic_type::type_null}; - - std::shared_ptr reference_column_; -}; - -/** - * User defined literal to have a shortcut creating a column object - * @param name Name of the column - * @param type - * @param attr Length of the column name - * @param null_opt - * @return A column object with a given name - */ -attribute_definition make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr = utils::null_attributes, null_option_type null_opt = null_option_type::NOT_NULL); - -template < typename Type > -attribute_definition make_column(const std::string &name, utils::field_attributes attr = utils::null_attributes, null_option_type null_opt = null_option_type::NOT_NULL) -{ - return make_column(name, utils::data_type_traits::type(0), attr, null_opt); -} -template <> -attribute_definition make_column(const std::string &name, utils::field_attributes attr, null_option_type null_opt); - -template < typename Type > -attribute_definition make_pk_column(const std::string &name, size_t size = 0) -{ - return make_column(name, { size, utils::constraints::PRIMARY_KEY }); -} - -template <> -attribute_definition make_pk_column(const std::string &name, size_t size); - -template < typename Type > -attribute_definition make_fk_column(const std::string &name, size_t size, const std::shared_ptr &ref_column) { - return {name, utils::data_type_traits::type(size), ref_column, { size, utils::constraints::FOREIGN_KEY }}; -} - -template < typename Type > -[[maybe_unused]] attribute_definition make_fk_column(const std::string &name, const std::shared_ptr &ref_column) -{ - return {name, utils::data_type_traits::type(0), 0, ref_column, { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL}; -} - -template <> -[[maybe_unused]] attribute_definition make_fk_column(const std::string &name, size_t size, const std::shared_ptr &ref_column); - -template < typename Type > -[[maybe_unused]] attribute_definition make_fk_column(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name) { - return { - name, utils::data_type_traits::type(size), 0, - std::make_shared(ref_column_name, ref_table_name, utils::data_type_traits::type(size), utils::constraints::FOREIGN_KEY), - { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL - }; -} - -template < typename Type > -[[maybe_unused]] attribute_definition make_fk_column(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name) { - return { - name, utils::data_type_traits::type(0), 0, - std::make_shared(ref_column_name, utils::data_type_traits::type(0), ref_table_name, attribute_options{utils::constraints::FOREIGN_KEY}), - { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL - }; -} - -template <> -[[maybe_unused]] attribute_definition make_fk_column(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name); - -template <> -[[maybe_unused]] attribute_definition make_fk_column(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name); - -} - -#endif //QUERY_COLUMN_DEFINITION_HPP diff --git a/include/matador/object/attribute_definition_generator.hpp b/include/matador/object/attribute_definition_generator.hpp index 30b24d4..22b029e 100644 --- a/include/matador/object/attribute_definition_generator.hpp +++ b/include/matador/object/attribute_definition_generator.hpp @@ -1,7 +1,7 @@ #ifndef QUERY_COLUMN_DEFINITION_GENERATOR_HPP #define QUERY_COLUMN_DEFINITION_GENERATOR_HPP -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/utils/access.hpp" #include "matador/utils/data_type_traits.hpp" @@ -24,9 +24,9 @@ public: fk_attribute_generator() = default; template - attribute_definition generate(const char *id, Type &x, const std::shared_ptr &ref_column) { + attribute generate(const char *id, Type &x, const std::shared_ptr &ref_column) { access::process(*this, x); - return attribute_definition{id, type_, 0, ref_column, {utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL}; + return attribute{id, type_, 0, ref_column, {utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL}; } template @@ -54,15 +54,15 @@ private: class attribute_definition_generator final { private: - attribute_definition_generator(std::vector &columns, const repository &repo); + attribute_definition_generator(std::vector &columns, const repository &repo); public: ~attribute_definition_generator() = default; template < class Type > - static std::vector generate(const repository &repo) + static std::vector generate(const repository &repo) { - std::vector columns; + std::vector columns; attribute_definition_generator gen(columns, repo); Type obj; access::process(gen, obj); @@ -70,8 +70,8 @@ public: } template < class Type > - static std::vector generate(const Type& obj, const repository &repo) { - std::vector columns; + static std::vector generate(const Type& obj, const repository &repo) { + std::vector columns; attribute_definition_generator gen(columns, repo); access::process(gen, obj); return columns; @@ -98,12 +98,12 @@ public: template void on_foreign_key(const char *id, Pointer &x) { - std::shared_ptr ref_column; + std::shared_ptr ref_column; std::type_index ti = typeid(typename Pointer::value_type); if (const auto result = determine_foreign_ref(std::type_index(ti))) { ref_column = *result; } else { - ref_column = std::make_shared(); + ref_column = std::make_shared(); insert_missing_reference_column(ti, ref_column); } if (x.empty()) { @@ -121,12 +121,12 @@ public: static void on_has_many_to_many(const char * /*id*/, ContainerType & /*cont*/, const utils::foreign_attributes &/*attr*/) {} private: - [[nodiscard]] utils::result, utils::error> determine_foreign_ref(const std::type_index &ti) const; - void insert_missing_reference_column(const std::type_index &ti, const std::shared_ptr& ref_column) const; + [[nodiscard]] utils::result, utils::error> determine_foreign_ref(const std::type_index &ti) const; + void insert_missing_reference_column(const std::type_index &ti, const std::shared_ptr& ref_column) const; private: size_t index_ = 0; - std::vector &columns_; + std::vector &columns_; const repository &repo_; fk_attribute_generator fk_column_generator_; diff --git a/include/matador/object/basic_object_info.hpp b/include/matador/object/basic_object_info.hpp index aa2008d..c534402 100644 --- a/include/matador/object/basic_object_info.hpp +++ b/include/matador/object/basic_object_info.hpp @@ -1,7 +1,7 @@ #ifndef BASIC_PROTOTYPE_INFO_HPP #define BASIC_PROTOTYPE_INFO_HPP -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/object/relation_endpoint.hpp" #include "matador/utils/identifier.hpp" @@ -24,8 +24,8 @@ public: [[nodiscard]] std::type_index type_index() const; [[nodiscard]] std::string name() const; - [[nodiscard]] const std::vector& attributes() const; - [[nodiscard]] std::shared_ptr reference_column() const; + [[nodiscard]] const std::vector& attributes() const; + [[nodiscard]] std::shared_ptr reference_column() const; [[nodiscard]] bool has_primary_key() const; [[nodiscard]] const utils::identifier& primary_key() const; @@ -49,14 +49,14 @@ public: [[nodiscard]] bool endpoints_empty() const; protected: - basic_object_info(std::shared_ptr node, const std::vector &attributes, utils::identifier &&pk, const std::shared_ptr &pk_as_fk_column); - basic_object_info(std::shared_ptr node, const std::vector &attributes); + basic_object_info(std::shared_ptr node, const std::vector &attributes, utils::identifier &&pk, const std::shared_ptr &pk_as_fk_column); + basic_object_info(std::shared_ptr node, const std::vector &attributes); protected: std::shared_ptr node_; /**< prototype node of the represented object type */ - std::vector attributes_; + std::vector attributes_; std::optional identifier_; - std::shared_ptr pk_as_fk_column_; + std::shared_ptr pk_as_fk_column_; t_endpoint_map relation_endpoints_; }; diff --git a/include/matador/object/object_info.hpp b/include/matador/object/object_info.hpp index d3d6cb2..3165827 100644 --- a/include/matador/object/object_info.hpp +++ b/include/matador/object/object_info.hpp @@ -12,15 +12,15 @@ public: using create_func = std::function()>; object_info(const std::shared_ptr& node, - const std::vector &attributes, + const std::vector &attributes, utils::identifier &&pk, - const std::shared_ptr &ref_column, + const std::shared_ptr &ref_column, create_func&& creator) : basic_object_info(node, attributes, std::move(pk), ref_column) , creator_(std::move(creator)){ } object_info(const std::shared_ptr& node, - const std::vector &attributes, + const std::vector &attributes, create_func&& creator) : basic_object_info(node, attributes) , creator_(std::move(creator)){ diff --git a/include/matador/object/repository.hpp b/include/matador/object/repository.hpp index 2f3e793..7dc0489 100644 --- a/include/matador/object/repository.hpp +++ b/include/matador/object/repository.hpp @@ -150,7 +150,7 @@ public: return utils::ok(basic_object_info_ref{result.value()->info()}); } - [[nodiscard]] utils::result, utils::error> reference_column( + [[nodiscard]] utils::result, utils::error> reference_column( const std::type_index &type_index) const; void dump(std::ostream &os) const; @@ -187,7 +187,7 @@ private: t_type_index_node_map nodes_by_type_; logger::logger log_; - std::unordered_map > missing_references_; + std::unordered_map > missing_references_; }; } diff --git a/include/matador/object/repository_node.hpp b/include/matador/object/repository_node.hpp index ac43c18..e6574ec 100644 --- a/include/matador/object/repository_node.hpp +++ b/include/matador/object/repository_node.hpp @@ -90,7 +90,7 @@ private: void unlink(); static utils::result make_and_attach_node(repository& repo, const std::string& name, const std::type_index& ti); - static std::shared_ptr determine_reference_column(const std::type_index& ti, + static std::shared_ptr determine_reference_column(const std::type_index& ti, const std::string& table_name, const primary_key_info& pk_info, repository& repo); diff --git a/include/matador/orm/schema.hpp b/include/matador/orm/schema.hpp index acbd308..411960b 100644 --- a/include/matador/orm/schema.hpp +++ b/include/matador/orm/schema.hpp @@ -46,7 +46,7 @@ public: [[nodiscard]] utils::result drop_table(); [[nodiscard]] utils::result drop_table(const std::string &table_name) const; - [[nodiscard]] utils::result, utils::error> describe_table(const std::string &table_name) const; + [[nodiscard]] utils::result, utils::error> describe_table(const std::string &table_name) const; [[nodiscard]] utils::result table_exists(const std::string &table_name) const; private: diff --git a/include/matador/orm/session.hpp b/include/matador/orm/session.hpp index 57b3eb3..b8e4f90 100644 --- a/include/matador/orm/session.hpp +++ b/include/matador/orm/session.hpp @@ -129,7 +129,7 @@ public: [[nodiscard]] utils::result, utils::error> fetch_all(const sql::query_context &q) const; [[nodiscard]] utils::result execute(const std::string &sql) const; - [[nodiscard]] std::vector describe_table(const std::string &table_name) const; + [[nodiscard]] std::vector describe_table(const std::string &table_name) const; [[nodiscard]] bool table_exists(const std::string &table_name) const; void dump_schema(std::ostream &os) const; @@ -150,7 +150,7 @@ private: const sql::dialect &dialect_; std::unique_ptr schema_; - mutable std::unordered_map> prototypes_; + mutable std::unordered_map> prototypes_; }; template diff --git a/include/matador/query/builder.hpp b/include/matador/query/builder.hpp index 4c9d23e..93ef439 100644 --- a/include/matador/query/builder.hpp +++ b/include/matador/query/builder.hpp @@ -1,12 +1,11 @@ #ifndef MATADOR_BUILDER_HPP #define MATADOR_BUILDER_HPP -#include "matador/object/attribute_definition.hpp" - #include "matador/query/column.hpp" #include "matador/query/table.hpp" #include "matador/utils/basic_types.hpp" +#include "matador/utils/constraints.hpp" #include @@ -24,26 +23,26 @@ private: std::string alias_; }; -class attribute { -public: - attribute(std::string name, const utils::basic_type type) - : name_(std::move(name)) - , type_(type) {} - - [[nodiscard]] const std::string& name() const; - [[nodiscard]] utils::basic_type type() const; - [[nodiscard]] const attribute_options& options() const; - -private: - friend class entity; - - std::string name_; - std::string alias_; - utils::basic_type type_{}; - attribute_options options_; - - entity* owner_{nullptr}; -}; +// class attribute { +// public: +// attribute(std::string name, const utils::basic_type type) +// : name_(std::move(name)) +// , type_(type) {} +// +// [[nodiscard]] const std::string& name() const; +// [[nodiscard]] utils::basic_type type() const; +// [[nodiscard]] const attribute_options& options() const; +// +// private: +// friend class entity; +// +// std::string name_; +// std::string alias_; +// utils::basic_type type_{}; +// attribute_options options_; +// +// entity* owner_{nullptr}; +// }; class constraint { public: diff --git a/include/matador/query/intermediates/query_create_intermediate.hpp b/include/matador/query/intermediates/query_create_intermediate.hpp index 21df036..0b5b9af 100644 --- a/include/matador/query/intermediates/query_create_intermediate.hpp +++ b/include/matador/query/intermediates/query_create_intermediate.hpp @@ -13,8 +13,8 @@ class query_create_intermediate : public query_intermediate { public: query_create_intermediate(); - executable_query table(const table &tab, std::initializer_list columns); - executable_query table(const query::table &tab, const std::vector &columns); + executable_query table(const table &tab, std::initializer_list columns); + executable_query table(const query::table &tab, const std::vector &columns); template executable_query table(const matador::query::table &tab, const object::repository &schema) { return this->table(tab, object::attribute_definition_generator::generate(schema)); diff --git a/include/matador/query/internal/query_parts.hpp b/include/matador/query/internal/query_parts.hpp index 272abb7..34fd587 100644 --- a/include/matador/query/internal/query_parts.hpp +++ b/include/matador/query/internal/query_parts.hpp @@ -9,7 +9,7 @@ #include "matador/query/column.hpp" #include "matador/query/table.hpp" -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/utils/placeholder.hpp" @@ -364,17 +364,17 @@ private: class query_create_table_part final : public query_part { public: - query_create_table_part(table table, std::vector columns); + query_create_table_part(table table, std::vector columns); [[nodiscard]] const 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_; }; class query_create_schema_part final : public query_part { diff --git a/include/matador/query/query_data.hpp b/include/matador/query/query_data.hpp index cb78514..015e573 100644 --- a/include/matador/query/query_data.hpp +++ b/include/matador/query/query_data.hpp @@ -4,7 +4,7 @@ #include #include -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/query/table.hpp" #include "matador/query/query_part.hpp" @@ -13,7 +13,7 @@ namespace matador::query { struct query_data { std::vector> parts{}; - std::vector columns{}; + std::vector columns{}; std::unordered_map tables{}; }; diff --git a/include/matador/sql/connection.hpp b/include/matador/sql/connection.hpp index 1e04ccb..872e5e0 100644 --- a/include/matador/sql/connection.hpp +++ b/include/matador/sql/connection.hpp @@ -1,7 +1,7 @@ #ifndef QUERY_CONNECTION_HPP #define QUERY_CONNECTION_HPP -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/sql/abstract_sql_logger.hpp" #include "matador/sql/connection_info.hpp" @@ -126,7 +126,7 @@ public: */ [[nodiscard]] utils::result rollback() const; - [[nodiscard]] utils::result, utils::error> describe(const std::string &table_name) const; + [[nodiscard]] utils::result, utils::error> describe(const std::string &table_name) const; [[nodiscard]] utils::result exists(const std::string &schema_name, const std::string &table_name) const; [[nodiscard]] utils::result exists(const std::string &table_name) const; diff --git a/include/matador/sql/interface/connection_impl.hpp b/include/matador/sql/interface/connection_impl.hpp index 73a969f..7cf7e1d 100644 --- a/include/matador/sql/interface/connection_impl.hpp +++ b/include/matador/sql/interface/connection_impl.hpp @@ -3,7 +3,7 @@ #include -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/sql/connection_info.hpp" #include "matador/sql/query_context.hpp" @@ -38,7 +38,7 @@ public: virtual utils::result, utils::error> fetch(const query_context &context) = 0; virtual utils::result, utils::error> prepare(const query_context &context) = 0; - virtual utils::result, utils::error> describe(const std::string &table) = 0; + virtual utils::result, utils::error> describe(const std::string &table) = 0; virtual utils::result exists(const std::string &schema_name, const std::string &table_name) = 0; [[nodiscard]] const class dialect &dialect() const; diff --git a/include/matador/sql/internal/query_result_impl.hpp b/include/matador/sql/internal/query_result_impl.hpp index a337f77..27b7347 100644 --- a/include/matador/sql/internal/query_result_impl.hpp +++ b/include/matador/sql/internal/query_result_impl.hpp @@ -12,7 +12,7 @@ #include "matador/sql/internal/query_result_pk_resolver.hpp" #include "matador/sql/record.hpp" -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include #include @@ -73,9 +73,9 @@ private: class query_result_impl { public: query_result_impl(std::unique_ptr &&reader, - std::vector &&prototype, size_t column_index = 0); + std::vector &&prototype, size_t column_index = 0); query_result_impl(std::unique_ptr &&reader, - const std::vector &prototype, size_t column_index = 0); + const std::vector &prototype, size_t column_index = 0); template void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes) { @@ -183,7 +183,7 @@ public: return true; } - [[nodiscard]] const std::vector &prototype() const; + [[nodiscard]] const std::vector &prototype() const; private: template @@ -209,7 +209,7 @@ private: protected: size_t column_index_ = 0; - std::vector prototype_; + std::vector prototype_; std::unique_ptr reader_; detail::pk_reader pk_reader_; std::stack type_stack_; diff --git a/include/matador/sql/query_context.hpp b/include/matador/sql/query_context.hpp index c2d6941..b6693df 100644 --- a/include/matador/sql/query_context.hpp +++ b/include/matador/sql/query_context.hpp @@ -1,7 +1,7 @@ #ifndef QUERY_QUERY_DATA_HPP #define QUERY_QUERY_DATA_HPP -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/query/table.hpp" #include "matador/utils/types.hpp" @@ -36,7 +36,7 @@ struct query_context { std::string command_name{}; std::string schema_name{}; std::string table_name{}; - std::vector prototype{}; + std::vector prototype{}; std::vector result_vars{}; std::vector bind_vars{}; std::vector bind_types{}; diff --git a/include/matador/sql/query_macro.hpp b/include/matador/sql/query_macro.hpp index 69b8aad..940c5bb 100644 --- a/include/matador/sql/query_macro.hpp +++ b/include/matador/sql/query_macro.hpp @@ -9,12 +9,12 @@ #include #include -#define FIELD(x) const sql::column x{*this, #x, ""}; +#define FIELD(x) const query::column x{*this, #x, ""}; #define QUERY_HELPER(C, ...) \ namespace matador::qh { \ namespace internal { \ -struct C##_query : sql::table { \ +struct C##_query : query::table { \ C##_query() : table(#C) {} \ MAP(FIELD, __VA_ARGS__) \ }; } \ diff --git a/include/matador/sql/query_result.hpp b/include/matador/sql/query_result.hpp index d2d510c..826d39e 100644 --- a/include/matador/sql/query_result.hpp +++ b/include/matador/sql/query_result.hpp @@ -1,7 +1,7 @@ #ifndef QUERY_QUERY_RESULT_HPP #define QUERY_QUERY_RESULT_HPP -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/sql/internal/query_result_impl.hpp" @@ -102,12 +102,12 @@ private: namespace detail { template < typename Type > -Type* create_prototype(const std::vector &/*prototype*/) { +Type* create_prototype(const std::vector &/*prototype*/) { return new Type{}; } template <> -record* create_prototype(const std::vector &prototype); +record* create_prototype(const std::vector &prototype); } diff --git a/source/core/CMakeLists.txt b/source/core/CMakeLists.txt index c2d5f25..ecdadf4 100644 --- a/source/core/CMakeLists.txt +++ b/source/core/CMakeLists.txt @@ -13,7 +13,7 @@ add_library(matador-core STATIC ../../include/matador/net/reactor.hpp ../../include/matador/net/select_fd_sets.hpp ../../include/matador/net/socket_interrupter.hpp - ../../include/matador/object/attribute_definition.hpp + ../../include/matador/object/attribute.hpp ../../include/matador/object/attribute_definition_generator.hpp ../../include/matador/object/basic_object_info.hpp ../../include/matador/object/error_code.hpp @@ -74,7 +74,7 @@ add_library(matador-core STATIC logger/log_manager.cpp logger/logger.cpp logger/rotating_file_sink.cpp - object/attribute_definition.cpp + object/attribute.cpp object/attribute_definition_generator.cpp object/basic_object_info.cpp object/error_code.cpp diff --git a/source/core/object/attribute.cpp b/source/core/object/attribute.cpp new file mode 100644 index 0000000..e629a40 --- /dev/null +++ b/source/core/object/attribute.cpp @@ -0,0 +1,178 @@ +#include "matador/object/attribute.hpp" + +#include +#include + +namespace matador::object { +attribute::attribute(const char *name) +: attribute(name, utils::basic_type::type_null, "", {utils::null_attributes}) { +} + +attribute::attribute(std::string name) +: attribute(std::move(name), utils::basic_type::type_null, "", {utils::null_attributes}) { +} + +attribute::attribute(std::string name, + const utils::basic_type type, + const utils::field_attributes &attr, + const null_option_type null_opt, + const int index) +: attribute(std::move(name), type, "", {attr, null_opt, index}) { +} + +attribute::attribute(std::string name, + const utils::basic_type type, + const int index, + const std::shared_ptr &ref_column, + const utils::field_attributes &attr, + const null_option_type null_opt) +: attribute(std::move(name), type, "", {attr, null_opt, index}, ref_column) { +} + +attribute::attribute( std::string name, const utils::basic_type type, const std::shared_ptr& ref_column ) +: attribute(std::move(name), type, {}, {}, ref_column) { +} + +attribute::attribute(std::string name, + const utils::basic_type type, + std::string table_name, + const attribute_options& options, + const std::shared_ptr& ref_column) +: name_(std::move(name)) +, table_name_(std::move(table_name)) +, options_( options ) +, type_( type ) +, reference_column_( ref_column ) { +} + +const std::string &attribute::name() const { + return name_; +} + +void attribute::name( const std::string& n ) { + name_ = n; +} + +std::string attribute::full_name() const { + return !table_name_.empty() ? table_name_ + "." + name_ : name_; +} + +int attribute::index() const { + return options_.index; +} + +const utils::field_attributes &attribute::attributes() const { + return options_.attributes; +} + +utils::field_attributes& attribute::attributes() { + return options_.attributes; +} + +bool attribute::is_nullable() const { + return options_.null_option == null_option_type::NULLABLE; +} + +utils::basic_type attribute::type() const { + return type_; +} + +const std::string& attribute::table_name() const { + return table_name_; +} + +void attribute::table_name( const std::string& name ) { + table_name_ = name; +} + +void attribute::change_type(const utils::basic_type type, const utils::field_attributes& attr) { + options_.attributes = attr; + type_ = type; +} + +std::shared_ptr attribute::reference_column() const { + return reference_column_; +} + +bool attribute::is_foreign_reference() const { + return reference_column_ != nullptr; +} + +bool attribute::is_integer() const { + return type_ >= utils::basic_type::type_int8 && type_ <= utils::basic_type::type_uint64; +} + +bool attribute::is_floating_point() const { + return type_ == utils::basic_type::type_float || type_ == utils::basic_type::type_double; +} + +bool attribute::is_bool() const { + return type_ == utils::basic_type::type_bool; +} + +bool attribute::is_string() const { + return type_ == utils::basic_type::type_text; +} + +bool attribute::is_varchar() const { + return type_ == utils::basic_type::type_varchar; +} + +bool attribute::is_date() const { + return type_ == utils::basic_type::type_date; +} + +bool attribute::is_time() const { + return type_ == utils::basic_type::type_time; +} + +bool attribute::is_blob() const { + return type_ == utils::basic_type::type_blob; +} + +bool attribute::is_null() const { + return type_ == utils::basic_type::type_null; +} + +attribute make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr, + null_option_type null_opt) { + return {name, type, attr, null_opt}; +} + +template<> +attribute make_column(const std::string &name, utils::field_attributes attr, + null_option_type null_opt) { + return make_column(name, utils::data_type_traits::type(attr.size()), attr, null_opt); +} + +template<> +attribute make_pk_column(const std::string &name, size_t size) { + return make_column(name, {size, utils::constraints::PRIMARY_KEY}); +} + +template<> +attribute make_fk_column(const std::string &name, size_t size, const std::shared_ptr &ref_column) { + return { + name, utils::data_type_traits::type(size), 0, ref_column, + {size, utils::constraints::FOREIGN_KEY}, null_option_type::NOT_NULL + }; +} + +template<> +attribute make_fk_column( const std::string& name, const std::string& ref_table_name, const std::string& ref_column_name ) { + return { + name, utils::basic_type::type_varchar, 0, + std::make_shared(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::FOREIGN_KEY}), + { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL + }; +} + +template<> +attribute make_fk_column(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name) { + const auto ref_column = std::make_shared(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::FOREIGN_KEY}); + return { + name, utils::data_type_traits::type(size), 0, ref_column, + {size, utils::constraints::FOREIGN_KEY}, null_option_type::NOT_NULL + }; +} +} diff --git a/source/core/object/attribute_definition.cpp b/source/core/object/attribute_definition.cpp deleted file mode 100644 index 94d5388..0000000 --- a/source/core/object/attribute_definition.cpp +++ /dev/null @@ -1,178 +0,0 @@ -#include "matador/object/attribute_definition.hpp" - -#include -#include - -namespace matador::object { -attribute_definition::attribute_definition(const char *name) -: attribute_definition(name, utils::basic_type::type_null, "", {utils::null_attributes}) { -} - -attribute_definition::attribute_definition(std::string name) -: attribute_definition(std::move(name), utils::basic_type::type_null, "", {utils::null_attributes}) { -} - -attribute_definition::attribute_definition(std::string name, - const utils::basic_type type, - const utils::field_attributes &attr, - const null_option_type null_opt, - const int index) -: attribute_definition(std::move(name), type, "", {attr, null_opt, index}) { -} - -attribute_definition::attribute_definition(std::string name, - const utils::basic_type type, - const int index, - const std::shared_ptr &ref_column, - const utils::field_attributes &attr, - const null_option_type null_opt) -: attribute_definition(std::move(name), type, "", {attr, null_opt, index}, ref_column) { -} - -attribute_definition::attribute_definition( std::string name, const utils::basic_type type, const std::shared_ptr& ref_column ) -: attribute_definition(std::move(name), type, {}, {}, ref_column) { -} - -attribute_definition::attribute_definition(std::string name, - const utils::basic_type type, - std::string table_name, - const attribute_options& options, - const std::shared_ptr& ref_column) -: name_(std::move(name)) -, table_name_(std::move(table_name)) -, options_( options ) -, type_( type ) -, reference_column_( ref_column ) { -} - -const std::string &attribute_definition::name() const { - return name_; -} - -void attribute_definition::name( const std::string& n ) { - name_ = n; -} - -std::string attribute_definition::full_name() const { - return !table_name_.empty() ? table_name_ + "." + name_ : name_; -} - -int attribute_definition::index() const { - return options_.index; -} - -const utils::field_attributes &attribute_definition::attributes() const { - return options_.attributes; -} - -utils::field_attributes& attribute_definition::attributes() { - return options_.attributes; -} - -bool attribute_definition::is_nullable() const { - return options_.null_option == null_option_type::NULLABLE; -} - -utils::basic_type attribute_definition::type() const { - return type_; -} - -const std::string& attribute_definition::table_name() const { - return table_name_; -} - -void attribute_definition::table_name( const std::string& name ) { - table_name_ = name; -} - -void attribute_definition::change_type(const utils::basic_type type, const utils::field_attributes& attr) { - options_.attributes = attr; - type_ = type; -} - -std::shared_ptr attribute_definition::reference_column() const { - return reference_column_; -} - -bool attribute_definition::is_foreign_reference() const { - return reference_column_ != nullptr; -} - -bool attribute_definition::is_integer() const { - return type_ >= utils::basic_type::type_int8 && type_ <= utils::basic_type::type_uint64; -} - -bool attribute_definition::is_floating_point() const { - return type_ == utils::basic_type::type_float || type_ == utils::basic_type::type_double; -} - -bool attribute_definition::is_bool() const { - return type_ == utils::basic_type::type_bool; -} - -bool attribute_definition::is_string() const { - return type_ == utils::basic_type::type_text; -} - -bool attribute_definition::is_varchar() const { - return type_ == utils::basic_type::type_varchar; -} - -bool attribute_definition::is_date() const { - return type_ == utils::basic_type::type_date; -} - -bool attribute_definition::is_time() const { - return type_ == utils::basic_type::type_time; -} - -bool attribute_definition::is_blob() const { - return type_ == utils::basic_type::type_blob; -} - -bool attribute_definition::is_null() const { - return type_ == utils::basic_type::type_null; -} - -attribute_definition make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr, - null_option_type null_opt) { - return {name, type, attr, null_opt}; -} - -template<> -attribute_definition make_column(const std::string &name, utils::field_attributes attr, - null_option_type null_opt) { - return make_column(name, utils::data_type_traits::type(attr.size()), attr, null_opt); -} - -template<> -attribute_definition make_pk_column(const std::string &name, size_t size) { - return make_column(name, {size, utils::constraints::PRIMARY_KEY}); -} - -template<> -attribute_definition make_fk_column(const std::string &name, size_t size, const std::shared_ptr &ref_column) { - return { - name, utils::data_type_traits::type(size), 0, ref_column, - {size, utils::constraints::FOREIGN_KEY}, null_option_type::NOT_NULL - }; -} - -template<> -attribute_definition make_fk_column( const std::string& name, const std::string& ref_table_name, const std::string& ref_column_name ) { - return { - name, utils::basic_type::type_varchar, 0, - std::make_shared(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::FOREIGN_KEY}), - { 0, utils::constraints::FOREIGN_KEY }, null_option_type::NOT_NULL - }; -} - -template<> -attribute_definition make_fk_column(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name) { - const auto ref_column = std::make_shared(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::FOREIGN_KEY}); - return { - name, utils::data_type_traits::type(size), 0, ref_column, - {size, utils::constraints::FOREIGN_KEY}, null_option_type::NOT_NULL - }; -} -} diff --git a/source/core/object/attribute_definition_generator.cpp b/source/core/object/attribute_definition_generator.cpp index c6782e3..f3be10f 100644 --- a/source/core/object/attribute_definition_generator.cpp +++ b/source/core/object/attribute_definition_generator.cpp @@ -3,7 +3,7 @@ namespace matador::object { -attribute_definition_generator::attribute_definition_generator(std::vector &columns, const repository &repo) +attribute_definition_generator::attribute_definition_generator(std::vector &columns, const repository &repo) : columns_(columns) , repo_(repo) {} @@ -12,11 +12,11 @@ void attribute_definition_generator::on_revision(const char *id, uint64_t &rev) on_attribute(id, rev); } -utils::result, utils::error> attribute_definition_generator::determine_foreign_ref(const std::type_index &ti) const { +utils::result, utils::error> attribute_definition_generator::determine_foreign_ref(const std::type_index &ti) const { return repo_.reference_column(ti); } -void attribute_definition_generator::insert_missing_reference_column(const std::type_index& ti, const std::shared_ptr& ref_column) const { +void attribute_definition_generator::insert_missing_reference_column(const std::type_index& ti, const std::shared_ptr& ref_column) const { const_cast(repo_).missing_references_.insert({ti, ref_column}); } diff --git a/source/core/object/basic_object_info.cpp b/source/core/object/basic_object_info.cpp index 8b9cb6c..0d49720 100644 --- a/source/core/object/basic_object_info.cpp +++ b/source/core/object/basic_object_info.cpp @@ -6,9 +6,9 @@ namespace matador::object { basic_object_info::basic_object_info(std::shared_ptr node, - const std::vector &attributes, + const std::vector &attributes, utils::identifier &&pk, - const std::shared_ptr &pk_as_fk_column) + const std::shared_ptr &pk_as_fk_column) : node_(std::move(node)) , attributes_(attributes) , identifier_(std::move(pk)) @@ -16,7 +16,7 @@ basic_object_info::basic_object_info(std::shared_ptr node, } basic_object_info::basic_object_info(std::shared_ptr node, - const std::vector &attributes) + const std::vector &attributes) : node_(std::move(node)) , attributes_(attributes) {} @@ -28,11 +28,11 @@ std::string basic_object_info::name() const { return node_->name(); } -const std::vector& basic_object_info::attributes() const { +const std::vector& basic_object_info::attributes() const { return attributes_; } -std::shared_ptr basic_object_info::reference_column() const { +std::shared_ptr basic_object_info::reference_column() const { return pk_as_fk_column_; } diff --git a/source/core/object/repository.cpp b/source/core/object/repository.cpp index 72e1635..10e1b4d 100644 --- a/source/core/object/repository.cpp +++ b/source/core/object/repository.cpp @@ -62,7 +62,7 @@ utils::result repository::basic_info( const return utils::ok(basic_object_info_ref{result.value()->info()}); } -utils::result, utils::error> repository::reference_column(const std::type_index &type_index) const { +utils::result, utils::error> repository::reference_column(const std::type_index &type_index) const { const auto result = find_node(type_index); if (result) { return utils::ok((*result)->info().reference_column()); diff --git a/source/core/object/repository_node.cpp b/source/core/object/repository_node.cpp index 684a44a..0946cf0 100644 --- a/source/core/object/repository_node.cpp +++ b/source/core/object/repository_node.cpp @@ -104,13 +104,13 @@ utils::result repository_node::make_and return repo.attach_node(node, ""); } -std::shared_ptr repository_node::determine_reference_column(const std::type_index& ti, +std::shared_ptr repository_node::determine_reference_column(const std::type_index& ti, const std::string& table_name, const primary_key_info& pk_info, repository& repo) { const auto it = repo.missing_references_.find(ti); if (it == repo.missing_references_.end()) { - return std::make_shared(pk_info.pk_column_name, pk_info.type, table_name, attribute_options{utils::constraints::FOREIGN_KEY}); + return std::make_shared(pk_info.pk_column_name, pk_info.type, table_name, attribute_options{utils::constraints::FOREIGN_KEY}); } auto ref_column = it->second; diff --git a/source/orm/orm/schema.cpp b/source/orm/orm/schema.cpp index 4a5a567..d319d02 100644 --- a/source/orm/orm/schema.cpp +++ b/source/orm/orm/schema.cpp @@ -127,7 +127,7 @@ matador::utils::result matador::orm::schema::drop_t return utils::ok(); } -matador::utils::result, matador::utils::error> matador::orm::schema::describe_table(const std::string& table_name) const { +matador::utils::result, matador::utils::error> matador::orm::schema::describe_table(const std::string& table_name) const { const auto c = pool_.acquire(); if (!c.valid()) { return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection.")); diff --git a/source/orm/orm/session.cpp b/source/orm/orm/session.cpp index 9b614da..cfd983b 100644 --- a/source/orm/orm/session.cpp +++ b/source/orm/orm/session.cpp @@ -103,7 +103,7 @@ utils::result, utils::error> session::fetch_all(c if (const auto rit = std::find_if(it->second.begin(), it->second.end(), [&col](const auto &value) { return value.name() == col.name(); }); rit != it->second.end()) { - const_cast(col).change_type(rit->type()); + const_cast(col).change_type(rit->type()); } } auto res = fetch(q); @@ -120,7 +120,7 @@ utils::result session::execute(const std::string &sql) con return execute(sql::query_context{sql}); } -std::vector session::describe_table(const std::string &table_name) const { +std::vector session::describe_table(const std::string &table_name) const { const auto c = cache_.pool().acquire(); if (!c.valid()) { throw std::logic_error("no database connection available"); diff --git a/source/orm/query/intermediates/fetchable_query.cpp b/source/orm/query/intermediates/fetchable_query.cpp index 39b0294..ac9e696 100644 --- a/source/orm/query/intermediates/fetchable_query.cpp +++ b/source/orm/query/intermediates/fetchable_query.cpp @@ -7,7 +7,7 @@ namespace matador::query { namespace detail { -sql::record *create_prototype(const std::vector &prototype) { +sql::record *create_prototype(const std::vector &prototype) { auto result = std::make_unique(); for (const auto &col: prototype) { result->append({ diff --git a/source/orm/query/intermediates/query_create_intermediate.cpp b/source/orm/query/intermediates/query_create_intermediate.cpp index 859968f..366723d 100644 --- a/source/orm/query/intermediates/query_create_intermediate.cpp +++ b/source/orm/query/intermediates/query_create_intermediate.cpp @@ -8,11 +8,11 @@ query_create_intermediate::query_create_intermediate() { context_->parts.push_back(std::make_unique()); } -executable_query query_create_intermediate::table(const class table &tab, const std::initializer_list columns) { - return this->table(tab, std::vector{columns}); +executable_query query_create_intermediate::table(const class table &tab, const std::initializer_list columns) { + return this->table(tab, std::vector{columns}); } -executable_query query_create_intermediate::table(const class table &tab, const std::vector &columns) { +executable_query query_create_intermediate::table(const class table &tab, const std::vector &columns) { context_->parts.push_back(std::make_unique(tab, columns)); return {context_}; } diff --git a/source/orm/query/internal/query_parts.cpp b/source/orm/query/internal/query_parts.cpp index 9911437..6e4c529 100644 --- a/source/orm/query/internal/query_parts.cpp +++ b/source/orm/query/internal/query_parts.cpp @@ -344,7 +344,7 @@ void query_create_part::accept(query_part_visitor &visitor) visitor.visit(*this); } -query_create_table_part::query_create_table_part(class table table, std::vector columns) +query_create_table_part::query_create_table_part(class table table, std::vector columns) : query_part(sql::dialect_token::Table) , table_(std::move(table)) , columns_(std::move(columns)) {} @@ -354,7 +354,7 @@ const table &query_create_table_part::table() const return table_; } -const std::vector &query_create_table_part::columns() const +const std::vector &query_create_table_part::columns() const { return columns_; } diff --git a/source/orm/query/internal/query_result_impl.cpp b/source/orm/query/internal/query_result_impl.cpp index 4a0470b..bbfbb7b 100644 --- a/source/orm/query/internal/query_result_impl.cpp +++ b/source/orm/query/internal/query_result_impl.cpp @@ -7,14 +7,14 @@ namespace matador::sql { detail::pk_reader::pk_reader(query_result_reader &reader) : reader_(reader) {} -query_result_impl::query_result_impl(std::unique_ptr &&reader, std::vector &&prototype, const size_t column_index) +query_result_impl::query_result_impl(std::unique_ptr &&reader, std::vector &&prototype, const size_t column_index) : column_index_(column_index) , prototype_(std::move(prototype)) , reader_(std::move(reader)) , pk_reader_(*reader_) {} -query_result_impl::query_result_impl(std::unique_ptr &&reader, const std::vector &prototype, const size_t column_index) +query_result_impl::query_result_impl(std::unique_ptr &&reader, const std::vector &prototype, const size_t column_index) : column_index_(column_index) , prototype_(prototype) , reader_(std::move(reader)) @@ -43,7 +43,7 @@ query_result_impl::on_attribute(const char *id, utils::value &val, const utils:: reader_->read_value(id, column_index_++, val, attr.size()); } -const std::vector& query_result_impl::prototype() const +const std::vector& query_result_impl::prototype() const { return prototype_; } diff --git a/source/orm/query/query_compiler.cpp b/source/orm/query/query_compiler.cpp index a83115b..9d3d732 100644 --- a/source/orm/query/query_compiler.cpp +++ b/source/orm/query/query_compiler.cpp @@ -291,7 +291,7 @@ void query_compiler::visit(internal::query_create_part &/*create_part*/) struct fk_context { std::string column; - std::shared_ptr reference_column; + std::shared_ptr reference_column; }; struct column_context @@ -300,7 +300,7 @@ struct column_context std::vector foreign_contexts; }; -std::string build_create_column(const object::attribute_definition &col, const sql::dialect &d, column_context &context); +std::string build_create_column(const object::attribute &col, const sql::dialect &d, column_context &context); void query_compiler::visit(internal::query_create_table_part &part) { @@ -387,7 +387,7 @@ void query_compiler::visit(internal::query_drop_table_part &part) query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name); } -std::string build_create_column(const object::attribute_definition &col, const sql::dialect &d, column_context &context) +std::string build_create_column(const object::attribute &col, const sql::dialect &d, column_context &context) { std::string result = d.prepare_identifier_string(col.name()) + " " + d.data_type_at(col.type()); if (col.attributes().size() > 0) { diff --git a/source/orm/sql/connection.cpp b/source/orm/sql/connection.cpp index f69b545..11b6bdd 100644 --- a/source/orm/sql/connection.cpp +++ b/source/orm/sql/connection.cpp @@ -137,7 +137,7 @@ utils::result connection::rollback() const { return utils::ok(); } -utils::result, utils::error> connection::describe(const std::string &table_name) const { +utils::result, utils::error> connection::describe(const std::string &table_name) const { return connection_->describe(table_name); } @@ -154,7 +154,7 @@ utils::result connection::execute(const std::string &sql) return connection_->execute(sql); } -bool has_unknown_columns(const std::vector &columns) { +bool has_unknown_columns(const std::vector &columns) { return std::any_of(std::begin(columns), std::end(columns), [](const auto &col) { return col.type() == utils::basic_type::type_null; }); @@ -229,7 +229,7 @@ utils::result, utils::error> connection::perform [&col](const auto &value) { return value.name() == col.name(); } ); if (col.type() == utils::basic_type::type_null && rit != result->end()) { - const_cast(col).change_type(rit->type()); + const_cast(col).change_type(rit->type()); } } } diff --git a/source/orm/sql/query_result.cpp b/source/orm/sql/query_result.cpp index d3cdabb..122ff6e 100644 --- a/source/orm/sql/query_result.cpp +++ b/source/orm/sql/query_result.cpp @@ -6,7 +6,7 @@ namespace matador::sql::detail { template<> -record *create_prototype(const std::vector &prototype) { +record *create_prototype(const std::vector &prototype) { auto result = std::make_unique(); for (const auto &col: prototype) { result->append({ diff --git a/test/backends/QueryBasicTest.cpp b/test/backends/QueryBasicTest.cpp index 39da107..9b050c5 100644 --- a/test/backends/QueryBasicTest.cpp +++ b/test/backends/QueryBasicTest.cpp @@ -1,7 +1,7 @@ #include "catch2/catch_test_macros.hpp" #include "catch2/matchers/catch_matchers_string.hpp" -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/object/repository.hpp" #include "matador/sql/connection.hpp" @@ -297,27 +297,27 @@ TEST_CASE_METHOD(QueryFixture, "Test describe table", "[query][describe][table]" "val_bool", /*"val_cstr", */"val_string", "val_varchar", // "val_date", "val_time", "val_binary"}; - const std::vector> type_check = { - [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_floating_point(); }, - [](const attribute_definition &cf) { return cf.is_floating_point(); }, - [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_integer(); }, + const std::vector> type_check = { + [](const attribute &cf) { return cf.is_integer(); }, + [](const attribute &cf) { return cf.is_integer(); }, + [](const attribute &cf) { return cf.is_floating_point(); }, + [](const attribute &cf) { return cf.is_floating_point(); }, + [](const attribute &cf) { return cf.is_integer(); }, + [](const attribute &cf) { return cf.is_integer(); }, + [](const attribute &cf) { return cf.is_integer(); }, + [](const attribute &cf) { return cf.is_integer(); }, + [](const attribute &cf) { return cf.is_integer(); }, + [](const attribute &cf) { return cf.is_integer(); }, // [](const attribute_definition &cf) { return cf.is_integer(); }, // [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_integer(); }, - [](const attribute_definition &cf) { return cf.is_bool(); }, + [](const attribute &cf) { return cf.is_integer(); }, + [](const attribute &cf) { return cf.is_bool(); }, // [](const attribute_definition &cf) { return cf.is_varchar(); }, - [](const attribute_definition &cf) { return cf.is_string(); }, - [](const attribute_definition &cf) { return cf.is_varchar(); }, + [](const attribute &cf) { return cf.is_string(); }, + [](const attribute &cf) { return cf.is_varchar(); }, // [](const attribute_definition &cf) { return cf.is_date(); }, // [](const attribute_definition &cf) { return cf.is_time(); }, - [](const attribute_definition &cf) { return cf.is_blob(); } + [](const attribute &cf) { return cf.is_blob(); } }; const auto &cols = columns.value(); diff --git a/test/backends/QueryTest.cpp b/test/backends/QueryTest.cpp index 1d16395..d1e2a20 100644 --- a/test/backends/QueryTest.cpp +++ b/test/backends/QueryTest.cpp @@ -1,6 +1,6 @@ #include "catch2/catch_test_macros.hpp" -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/query/criteria.hpp" #include "matador/query/generator.hpp" diff --git a/test/backends/StatementTest.cpp b/test/backends/StatementTest.cpp index 5b0d773..87b2da4 100644 --- a/test/backends/StatementTest.cpp +++ b/test/backends/StatementTest.cpp @@ -1,6 +1,6 @@ #include -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" #include "matador/sql/connection.hpp" diff --git a/test/core/object/AttributeDefinitionGeneratorTest.cpp b/test/core/object/AttributeDefinitionGeneratorTest.cpp index bfbd3f2..d9e1719 100644 --- a/test/core/object/AttributeDefinitionGeneratorTest.cpp +++ b/test/core/object/AttributeDefinitionGeneratorTest.cpp @@ -20,15 +20,15 @@ TEST_CASE("Generate column definitions from object", "[column][definition][gener auto columns = attribute_definition_generator::generate(repo); const std::vector expected_columns = { - attribute_definition{"product_name", basic_type::type_varchar, constraints::PRIMARY_KEY, null_option_type::NOT_NULL }, - attribute_definition{"supplier_id", basic_type::type_uint32, constraints::FOREIGN_KEY, null_option_type::NOT_NULL }, - attribute_definition{"category_id", basic_type::type_uint32, constraints::FOREIGN_KEY, null_option_type::NOT_NULL }, - attribute_definition{"quantity_per_unit", basic_type::type_varchar, null_attributes, null_option_type::NOT_NULL }, - attribute_definition{"unit_price", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL }, - attribute_definition{"units_in_stock", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL }, - attribute_definition{"units_in_order", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL }, - attribute_definition{"reorder_level", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL }, - attribute_definition{"discontinued", basic_type::type_bool, null_attributes, null_option_type::NOT_NULL } + attribute{"product_name", basic_type::type_varchar, constraints::PRIMARY_KEY, null_option_type::NOT_NULL }, + attribute{"supplier_id", basic_type::type_uint32, constraints::FOREIGN_KEY, null_option_type::NOT_NULL }, + attribute{"category_id", basic_type::type_uint32, constraints::FOREIGN_KEY, null_option_type::NOT_NULL }, + attribute{"quantity_per_unit", basic_type::type_varchar, null_attributes, null_option_type::NOT_NULL }, + attribute{"unit_price", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL }, + attribute{"units_in_stock", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL }, + attribute{"units_in_order", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL }, + attribute{"reorder_level", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL }, + attribute{"discontinued", basic_type::type_bool, null_attributes, null_option_type::NOT_NULL } }; REQUIRE(!columns.empty()); REQUIRE(columns.size() == expected_columns.size()); @@ -46,9 +46,9 @@ TEST_CASE("Generate columns from object with nullable columns", "[column generat auto columns = attribute_definition_generator::generate(repo); const std::vector expected_columns = { - attribute_definition{"id", basic_type::type_uint32, constraints::PRIMARY_KEY, null_option_type::NOT_NULL }, - attribute_definition{"name", basic_type::type_varchar, null_attributes, null_option_type::NOT_NULL }, - attribute_definition{"age", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL } + attribute{"id", basic_type::type_uint32, constraints::PRIMARY_KEY, null_option_type::NOT_NULL }, + attribute{"name", basic_type::type_varchar, null_attributes, null_option_type::NOT_NULL }, + attribute{"age", basic_type::type_uint32, null_attributes, null_option_type::NOT_NULL } }; REQUIRE(!columns.empty()); REQUIRE(columns.size() == expected_columns.size()); diff --git a/test/orm/backend/test_connection.cpp b/test/orm/backend/test_connection.cpp index 0c75411..c0877e9 100644 --- a/test/orm/backend/test_connection.cpp +++ b/test/orm/backend/test_connection.cpp @@ -57,8 +57,8 @@ utils::result, utils::error> test_connectio return utils::ok(std::move(s)); } -utils::result, utils::error> test_connection::describe(const std::string &/*table*/) { - return utils::ok(std::vector{}); +utils::result, utils::error> test_connection::describe(const std::string &/*table*/) { + return utils::ok(std::vector{}); } utils::result test_connection::exists(const std::string &/*schema_name*/, const std::string &/*table_name*/) { diff --git a/test/orm/backend/test_connection.hpp b/test/orm/backend/test_connection.hpp index 4f756c9..70a640c 100644 --- a/test/orm/backend/test_connection.hpp +++ b/test/orm/backend/test_connection.hpp @@ -19,7 +19,7 @@ public: utils::result execute(const std::string &stmt) override; utils::result, utils::error> fetch(const sql::query_context &context) override; utils::result, utils::error> prepare(const sql::query_context &context) override; - utils::result, utils::error> describe(const std::string &table) override; + utils::result, utils::error> describe(const std::string &table) override; utils::result exists(const std::string &schema_name, const std::string &table_name) override; [[nodiscard]] std::string to_escaped_string( const utils::blob& value ) const override; diff --git a/test/orm/sql/ColumnTest.cpp b/test/orm/sql/ColumnTest.cpp index 24a44a5..7c45a72 100644 --- a/test/orm/sql/ColumnTest.cpp +++ b/test/orm/sql/ColumnTest.cpp @@ -1,12 +1,12 @@ #include -#include "matador/object/attribute_definition.hpp" +#include "matador/object/attribute.hpp" using namespace matador::object; using namespace matador::utils; TEST_CASE("Test create empty column", "[column]") { - attribute_definition c("name"); + attribute c("name"); REQUIRE(c.name() == "name"); REQUIRE(c.index() == -1); @@ -21,11 +21,11 @@ TEST_CASE("Test create empty column", "[column]") { } TEST_CASE("Test copy and move column", "[column]") { - attribute_definition c( + attribute c( "name", basic_type::type_varchar, 2, - std::make_shared("author", basic_type::type_uint32, "books", attribute_options{constraints::FOREIGN_KEY}), + std::make_shared("author", basic_type::type_uint32, "books", attribute_options{constraints::FOREIGN_KEY}), {255, constraints::FOREIGN_KEY}, null_option_type::NOT_NULL );