From 2060883d59a0c9dc90c5e970471dbed59a369094 Mon Sep 17 00:00:00 2001 From: Sascha Kuehl Date: Tue, 16 Jan 2024 22:09:19 +0100 Subject: [PATCH] query preparations for std::optional --- include/matador/sql/column.hpp | 4 +- include/matador/utils/field_attributes.hpp | 1 + src/sql/column.cpp | 55 ++++++++++------------ src/sql/query_builder.cpp | 3 ++ test/CMakeLists.txt | 3 +- test/QueryBuilderTest.cpp | 7 +-- test/StatementTest.cpp | 2 +- test/models/optional.hpp | 30 ++++++++++++ 8 files changed, 69 insertions(+), 36 deletions(-) create mode 100644 test/models/optional.hpp diff --git a/include/matador/sql/column.hpp b/include/matador/sql/column.hpp index ef0174d..d5d020a 100644 --- a/include/matador/sql/column.hpp +++ b/include/matador/sql/column.hpp @@ -130,10 +130,10 @@ private: */ column operator "" _col(const char *name, size_t len); -column make_column(const std::string &name, data_type_t type, utils::field_attributes attr = utils::null_attributes); +column make_column(const std::string &name, data_type_t type, utils::field_attributes attr = utils::not_null_attributes); template < typename Type > -column make_column(const std::string &name, utils::field_attributes attr = utils::null_attributes) +column make_column(const std::string &name, utils::field_attributes attr = utils::not_null_attributes) { return make_column(name, data_type_traits::builtin_type(0), attr); } diff --git a/include/matador/utils/field_attributes.hpp b/include/matador/utils/field_attributes.hpp index 9736b2c..0239bd0 100644 --- a/include/matador/utils/field_attributes.hpp +++ b/include/matador/utils/field_attributes.hpp @@ -30,6 +30,7 @@ private: }; const field_attributes null_attributes {}; +const field_attributes not_null_attributes { constraints::NOT_NULL }; } #endif //QUERY_FIELD_ATTRIBUTES_HPP diff --git a/src/sql/column.cpp b/src/sql/column.cpp index 261d275..5c8f233 100644 --- a/src/sql/column.cpp +++ b/src/sql/column.cpp @@ -5,33 +5,26 @@ namespace matador::sql { column::column(sql_function_t func, std::string name) -: name_(std::move(name)) -, type_(data_type_t::type_int) -, attributes_(utils::null_attributes) -, function_(func) {} + : name_(std::move(name)), type_(data_type_t::type_int), attributes_(utils::null_attributes), function_(func) +{} column::column(const char *name, std::string alias) -: name_(name) -, attributes_(utils::null_attributes) -, alias_(std::move(alias)) {} + : name_(name), attributes_(utils::null_attributes), alias_(std::move(alias)) +{} column::column(std::string name, std::string alias) -: name_(std::move(name)) -, attributes_(utils::null_attributes) -, alias_(std::move(alias)) {} + : name_(std::move(name)), attributes_(utils::null_attributes), alias_(std::move(alias)) +{} column::column(std::string name, data_type_t type, utils::field_attributes attr) -: name_(std::move(name)) -, type_(type) -, attributes_(attr) {} + : name_(std::move(name)), type_(type), attributes_(attr) +{} -column::column(std::string name, data_type_t type, size_t index, std::string ref_table, std::string ref_column, utils::field_attributes attr) -: name_(std::move(name)) -, index_(index) -, type_(type) -, attributes_(attr) -, ref_table_(std::move(ref_table)) -, ref_column_(std::move(ref_column)) {} +column::column(std::string name, data_type_t type, size_t index, std::string ref_table, std::string ref_column, + utils::field_attributes attr) + : name_(std::move(name)), index_(index), type_(type), attributes_(attr), ref_table_(std::move(ref_table)), + ref_column_(std::move(ref_column)) +{} const std::string &column::name() const { @@ -81,7 +74,7 @@ void column::alias(const std::string &as) std::string column::str() const { any_type_to_visitor visitor; - std::visit(visitor, const_cast(value_)); + std::visit(visitor, const_cast(value_)); return visitor.result; } @@ -100,26 +93,30 @@ column operator "" _col(const char *name, size_t len) return {std::string(name, len)}; } -column make_column( const std::string& name, data_type_t type, utils::field_attributes attr ) +column make_column(const std::string &name, data_type_t type, utils::field_attributes attr) { - return {name, type, attr}; + return {name, type, attr}; } template<> -column make_column( const std::string& name, utils::field_attributes attr ) +column make_column(const std::string &name, utils::field_attributes attr) { - return make_column(name, data_type_traits::builtin_type(attr.size()), attr); + if (attr.options() == utils::constraints::NONE) { + return make_column(name, data_type_traits::builtin_type(attr.size()), { attr.size(), utils::constraints::NOT_NULL}); + } + return make_column(name, data_type_traits::builtin_type(attr.size()), attr); } template<> -column make_pk_column( const std::string& name, size_t size ) +column make_pk_column(const std::string &name, size_t size) { - return make_column(name, { size, utils::constraints::FOREIGN_KEY }); + return make_column(name, {size, utils::constraints::FOREIGN_KEY}); } template<> -[[maybe_unused]] column make_fk_column(const std::string& name, size_t size, const std::string &ref_table, const std::string &ref_column) +[[maybe_unused]] column make_fk_column(const std::string &name, size_t size, const std::string &ref_table, + const std::string &ref_column) { - return {name, data_type_traits::builtin_type(size), 0, ref_table, ref_column, { size, utils::constraints::PRIMARY_KEY | utils::constraints::NOT_NULL}}; + return {name, data_type_traits::builtin_type(size), 0, ref_table, ref_column, {size, utils::constraints::PRIMARY_KEY | utils::constraints::NOT_NULL}}; } } \ No newline at end of file diff --git a/src/sql/query_builder.cpp b/src/sql/query_builder.cpp index b2e4911..401ca43 100644 --- a/src/sql/query_builder.cpp +++ b/src/sql/query_builder.cpp @@ -476,6 +476,9 @@ std::string build_create_column(const column &col, const dialect &d, column_cont if (is_constraint_set(col.attributes().options(), utils::constraints::NOT_NULL)) { result.append(" NOT NULL"); } + if (is_constraint_set(col.attributes().options(), utils::constraints::UNIQUE)) { + result.append(" UNIQUE"); + } if (is_constraint_set(col.attributes().options(), utils::constraints::PRIMARY_KEY)) { context.primary_keys.emplace_back(col.name()); } diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 0740046..376a072 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -31,7 +31,8 @@ add_executable(tests QueryBuilderTest.cpp models/coordinate.hpp models/location.hpp TypeTraitsTest.cpp - Databases.hpp) + Databases.hpp + models/optional.hpp) target_link_libraries(tests PRIVATE Catch2::Catch2WithMain matador diff --git a/test/QueryBuilderTest.cpp b/test/QueryBuilderTest.cpp index 6c59c9a..c06ecb5 100644 --- a/test/QueryBuilderTest.cpp +++ b/test/QueryBuilderTest.cpp @@ -6,6 +6,7 @@ #include using namespace matador::sql; +using namespace matador::utils; TEST_CASE("Create table sql statement string", "[query]") { dialect d = dialect_builder::builder().create().build(); @@ -16,17 +17,17 @@ TEST_CASE("Create table sql statement string", "[query]") { make_column("age") }).compile(); - REQUIRE(q.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255), "age" INTEGER, CONSTRAINT PK_person PRIMARY KEY (id)))##"); + REQUIRE(q.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##"); REQUIRE(q.table_name == "person"); q = query.create().table("person", { make_pk_column("id"), - make_column("name", 255), + make_column("name", { 255, constraints::UNIQUE | constraints::NOT_NULL }), make_column("age"), make_fk_column("address", "address", "id") }).compile(); - REQUIRE(q.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255), "age" INTEGER, "address" BIGINT, CONSTRAINT PK_person PRIMARY KEY (id), CONSTRAINT FK_person_address FOREIGN KEY (address) REFERENCES address(id)))##"); + REQUIRE(q.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL UNIQUE, "age" INTEGER NOT NULL, "address" BIGINT, CONSTRAINT PK_person PRIMARY KEY (id), CONSTRAINT FK_person_address FOREIGN KEY (address) REFERENCES address(id)))##"); REQUIRE(q.table_name == "person"); } diff --git a/test/StatementTest.cpp b/test/StatementTest.cpp index 2a08275..6d0515d 100644 --- a/test/StatementTest.cpp +++ b/test/StatementTest.cpp @@ -48,7 +48,7 @@ private: }; }; -TEMPLATE_TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[statement]", Sqlite, Postgres) +TEMPLATE_TEST_CASE_METHOD(StatementTestFixture, "Create prepared statement", "[statement]", Sqlite, Postgres, MySql) { auto &s = StatementTestFixture::session(); auto &planes = StatementTestFixture::planes(); diff --git a/test/models/optional.hpp b/test/models/optional.hpp new file mode 100644 index 0000000..88a59f2 --- /dev/null +++ b/test/models/optional.hpp @@ -0,0 +1,30 @@ +#ifndef QUERY_OPTIONAL_HPP +#define QUERY_OPTIONAL_HPP + +#include "matador/utils/access.hpp" +#include "matador/utils/field_attributes.hpp" + +#include +#include + +namespace matador::test { + +struct optional +{ + unsigned long id{}; + std::optional name; + std::optional age{}; + + template + void process(Operator &op) { + namespace field = matador::utils::access; + using namespace matador::utils; + field::primary_key(op, "id", id); + field::attribute(op, "name", name, 255); + field::attribute(op, "age", age); + } +}; + +} + +#endif //QUERY_OPTIONAL_HPP