From 907bcf90a69a6907d0f183516a79193834104d50 Mon Sep 17 00:00:00 2001 From: sascha Date: Thu, 19 Mar 2026 11:54:50 +0100 Subject: [PATCH] some code formatting --- backends/postgres/test/CMakeLists.txt | 6 +- source/orm/query/query_builder.cpp | 222 +++++++++++++------------- 2 files changed, 116 insertions(+), 112 deletions(-) diff --git a/backends/postgres/test/CMakeLists.txt b/backends/postgres/test/CMakeLists.txt index 87ceb6e..575e930 100644 --- a/backends/postgres/test/CMakeLists.txt +++ b/backends/postgres/test/CMakeLists.txt @@ -37,9 +37,9 @@ set(TEST_SOURCES ../../../test/backends/SequenceFixture.hpp ../../../test/backends/SequenceFixture.cpp ../../../test/backends/SequenceTest.cpp - ../../../test/backends/TableSequenceFixture.hpp - ../../../test/backends/TableSequenceFixture.cpp - ../../../test/backends/TableSequenceTest.cpp + ../../../test/backends/TableSequenceFixture.hpp + ../../../test/backends/TableSequenceFixture.cpp + ../../../test/backends/TableSequenceTest.cpp ) set(LIBRARY_TEST_TARGET PostgresTests) diff --git a/source/orm/query/query_builder.cpp b/source/orm/query/query_builder.cpp index 80f3c9c..deef5b9 100644 --- a/source/orm/query/query_builder.cpp +++ b/source/orm/query/query_builder.cpp @@ -17,16 +17,15 @@ #include "matador/sql/dialect.hpp" namespace matador::query { - -sql::query_context query_builder::compile(const query_data &data, - const sql::dialect &d, - const std::optional> conn) -{ +sql::query_context query_builder::compile(const query_data& data, + const sql::dialect& d, + const std::optional> + conn) { data_ = &data; dialect_ = &d; connection_ = conn; query_ = {}; - for (const auto &part: data.parts) { + for (const auto& part : data.parts) { part->accept(*this); } finisher_(query_); @@ -37,10 +36,10 @@ sql::query_context query_builder::compile(const query_data &data, return {query_}; } -void build_columns_with_name_only(std::string &out, const std::vector &cols, const sql::dialect &d); -void build_columns(std::string &out, const std::vector &cols, const sql::dialect &d); -void build_fetchable_columns(sql::query_context &ctx, const std::vector &cols, const sql::dialect &d); -void prepare_prototype(std::vector &prototype, const table_column &col); +void build_columns_with_name_only(std::string& out, const std::vector& cols, const sql::dialect& d); +void build_columns(std::string& out, const std::vector& cols, const sql::dialect& d); +void build_fetchable_columns(sql::query_context& ctx, const std::vector& cols, const sql::dialect& d); +void prepare_prototype(std::vector& prototype, const table_column& col); void query_builder::visit(internal::query_alter_part& part) { query_.sql = dialect_->token_at(part.token()); @@ -49,7 +48,7 @@ void query_builder::visit(internal::query_alter_part& part) { void query_builder::visit(internal::query_alter_table_part& part) { query_.command = sql::sql_command::AlterTable; query_.sql += " " + dialect_->token_at(part.token()) + " " + - dialect_->prepare_identifier_string(part.table().name()); + dialect_->prepare_identifier_string(part.table().name()); } void query_builder::visit(internal::query_add_key_constraint_part& part) { @@ -74,7 +73,7 @@ void query_builder::visit(internal::query_add_foreign_key_reference_part& part) query_.sql += ")"; } -void query_builder::visit(internal::query_add_constraint_part_by_constraint &part) { +void query_builder::visit(internal::query_add_constraint_part_by_constraint& part) { query_.sql += build_add_constraint_string(part.constraint()); } @@ -86,7 +85,7 @@ void query_builder::visit(internal::query_drop_key_constraint_part_by_constraint query_.sql += " " + build_drop_constraint_string(part.constraint()); } -void query_builder::visit(internal::query_select_part &part) { +void query_builder::visit(internal::query_select_part& part) { query_.command = sql::sql_command::Select; query_.sql = dialect_->select() + " "; @@ -109,11 +108,11 @@ void query_builder::visit(internal::query_select_currval_part& part) { prepare_prototype(query_.prototype, part.sequence_name()); } -void query_builder::visit(internal::query_from_part &part) { +void query_builder::visit(internal::query_from_part& part) { query_.table_name = part.tables().front().name(); query_.sql += " " + dialect_->from() + " "; - if (const auto &tables = part.tables(); tables.size() < 2) { - for (const auto &tab: tables) { + if (const auto& tables = part.tables(); tables.size() < 2) { + for (const auto& tab : tables) { query_.sql += build_table_name(*dialect_, tab); } } else { @@ -126,30 +125,30 @@ void query_builder::visit(internal::query_from_part &part) { } } -void query_builder::visit(internal::query_join_table_part &part) { +void query_builder::visit(internal::query_join_table_part& part) { query_.sql += " " + build_table_name(part.token(), *dialect_, part.table()); } -void query_builder::visit(internal::query_join_query_part &part) { +void query_builder::visit(internal::query_join_query_part& part) { query_.sql += " " + dialect_->join() + " (" + part.query().str(*dialect_) + ")"; } -void query_builder::visit(internal::query_on_part &part) { +void query_builder::visit(internal::query_on_part& part) { criteria_evaluator evaluator(*dialect_, query_); query_.sql += " " + dialect_->on() + - " " + evaluator.evaluate(part.condition()); + " " + evaluator.evaluate(part.condition()); } -void query_builder::visit(internal::query_where_part &part) { +void query_builder::visit(internal::query_where_part& part) { criteria_evaluator evaluator(*dialect_, query_); query_.sql += " " + dialect_->where() + - " " + evaluator.evaluate(part.condition()); + " " + evaluator.evaluate(part.condition()); } -void query_builder::visit(internal::query_group_by_part &part) { +void query_builder::visit(internal::query_group_by_part& part) { query_.sql += " " + dialect_->group_by() + " "; if (part.columns().size() < 2) { - for (const auto &col: part.columns()) { + for (const auto& col : part.columns()) { query_.sql.append(dialect_->prepare_identifier_string(col.name())); } } else { @@ -162,10 +161,10 @@ void query_builder::visit(internal::query_group_by_part &part) { } } -void query_builder::visit(internal::query_order_by_part &part) { +void query_builder::visit(internal::query_order_by_part& part) { query_.sql += " " + dialect_->order_by() + " "; if (part.columns().size() < 2) { - for (const auto &col: part.columns()) { + for (const auto& col : part.columns()) { query_.sql.append(dialect_->prepare_identifier_string(col.canonical_name())); } } else { @@ -178,66 +177,72 @@ void query_builder::visit(internal::query_order_by_part &part) { } } -void query_builder::visit(internal::query_order_by_asc_part &/*order_by_asc_part*/) { +void query_builder::visit(internal::query_order_by_asc_part&/*order_by_asc_part*/) { query_.sql += " " + dialect_->asc(); } -void query_builder::visit(internal::query_order_by_desc_part &/*order_by_desc_part*/) { +void query_builder::visit(internal::query_order_by_desc_part&/*order_by_desc_part*/) { query_.sql += " " + dialect_->desc(); } -void query_builder::visit(internal::query_offset_part &part) { +void query_builder::visit(internal::query_offset_part& part) { query_.sql += " " + dialect_->offset() + " " + std::to_string(part.offset()); } -void query_builder::visit(internal::query_limit_part &part) { +void query_builder::visit(internal::query_limit_part& part) { query_.sql += " " + dialect_->limit() + " " + std::to_string(part.limit()); } -void query_builder::visit(internal::query_insert_part &/*insert_part*/) { +void query_builder::visit(internal::query_insert_part&/*insert_part*/) { query_.command = sql::sql_command::Insert; query_.sql = dialect_->insert(); } -void query_builder::visit(internal::query_into_part &part) { +void query_builder::visit(internal::query_into_part& part) { query_.table_name = part.table().name(); query_.sql += " " + dialect_->into() + - " " + dialect_->prepare_identifier_string(part.table().name()) + " ("; + " " + dialect_->prepare_identifier_string(part.table().name()) + " ("; build_columns_with_name_only(query_.sql, part.columns(), *dialect_); query_.sql += ")"/* + result*/; } -struct value_visitor { - value_visitor(attribute_string_writer &w, sql::query_context &ctx) - : value_to_string_visitor(w, ctx) {} - - void operator()(const utils::database_type &val) { - std::visit(value_to_string_visitor, val); - +struct value_visitor +{ + value_visitor(attribute_string_writer& w, sql::query_context& ctx) + : value_to_string_visitor(w, ctx) { } - void operator()(const utils::placeholder &/*val*/) { - value_to_string_visitor.query.bind_vars.emplace_back(std::string("value_") + std::to_string(value_to_string_visitor.query.bind_vars.size() + 1)); - value_to_string_visitor.result = value_to_string_visitor.writer->dialect().next_placeholder(value_to_string_visitor.query.bind_vars); + + void operator()(const utils::database_type& val) { + std::visit(value_to_string_visitor, val); + } + + void operator()(const utils::placeholder&/*val*/) { + value_to_string_visitor.query.bind_vars.emplace_back( + std::string("value_") + std::to_string(value_to_string_visitor.query.bind_vars.size() + 1)); + value_to_string_visitor.result = value_to_string_visitor.writer->dialect().next_placeholder( + value_to_string_visitor.query.bind_vars); } internal::basic_type_to_string_visitor value_to_string_visitor; }; -std::string query_builder::determine_value(const sql::dialect &d, sql::query_context& ctx, const abstract_column_expression &exp) { - attribute_string_writer writer(d, {}); - expression_evaluator v(d, ctx); - exp.accept(v); +std::string query_builder::determine_value(const sql::dialect& d, sql::query_context& ctx, + const abstract_column_expression& exp) { + attribute_string_writer writer(d, {}); + expression_evaluator v(d, ctx); + exp.accept(v); - return v.result(); + return v.result(); } -std::string query_builder::determine_value(value_visitor &visitor, const std::variant &val) { - std::visit(visitor, val); - return visitor.value_to_string_visitor.result; +std::string query_builder::determine_value(value_visitor& visitor, + const std::variant& val) { + std::visit(visitor, val); + return visitor.value_to_string_visitor.result; } -void query_builder::visit(internal::query_values_part &part) { +void query_builder::visit(internal::query_values_part& part) { query_.sql += " " + dialect_->values(); attribute_string_writer writer(*dialect_, connection_); @@ -245,13 +250,13 @@ void query_builder::visit(internal::query_values_part &part) { value_visitor visitor(writer, query_); std::string result{"("}; if (part.values().size() < 2) { - for (const auto& val: part.values()) { + for (const auto& val : part.values()) { result.append(determine_value(visitor, val)); } } else { auto it = part.values().begin(); auto val = *it++; - result.append(determine_value(visitor, val)); + result.append(determine_value(visitor, val)); for (; it != part.values().end(); ++it) { result.append(", "); val = *it; @@ -263,45 +268,42 @@ void query_builder::visit(internal::query_values_part &part) { query_.sql += " " + result; } -void query_builder::visit(internal::query_returning_part &part) { +void query_builder::visit(internal::query_returning_part& part) { query_.mode = sql::return_mode::Rows; query_.sql += " " + dialect_->returning() + " "; build_fetchable_columns(query_, part.columns(), *dialect_); } -void query_builder::visit(internal::query_update_part &part) { +void query_builder::visit(internal::query_update_part& part) { query_.command = sql::sql_command::Update; query_.table_name = part.table().name(); query_.sql += build_table_name(part.token(), *dialect_, query_.table_name); } -void query_builder::visit(internal::query_delete_part &/*delete_part*/) { +void query_builder::visit(internal::query_delete_part&/*delete_part*/) { query_.command = sql::sql_command::Delete; query_.sql = dialect_->remove(); } -void query_builder::visit(internal::query_delete_from_part &part) -{ +void query_builder::visit(internal::query_delete_from_part& part) { query_.table_name = part.table().name(); query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name); } -void query_builder::visit(internal::query_create_part &/*create_part*/) -{ +void query_builder::visit(internal::query_create_part&/*create_part*/) { query_.command = sql::sql_command::CreateTable; query_.sql = dialect_->create(); } -void build_create_column(std::string &out, const table_column &col, const sql::dialect &d); -std::string build_constraint(const table_constraint &cons, const sql::dialect &d); +void build_create_column(std::string& out, const table_column& col, const sql::dialect& d); +std::string build_constraint(const table_constraint& cons, const sql::dialect& d); -void query_builder::visit(internal::query_create_table_part &part) -{ +void query_builder::visit(internal::query_create_table_part& part) { query_.sql += " " + dialect_->table() + " " + dialect_->prepare_identifier_string(part.table().name()) + " ("; query_.table_name = part.table().name(); - finisher_ = [](sql::query_context &ctx) { ctx.sql += ")"; }; + finisher_ = [](sql::query_context& ctx) { ctx.sql += ")"; }; } void query_builder::visit(internal::query_create_table_columns_part& part) { @@ -329,22 +331,22 @@ void query_builder::visit(internal::query_create_sequence_part& part) { query_.sql += " " + dialect_->sequence() + " " + dialect_->prepare_identifier_string(part.sequence_name()); } -void query_builder::visit( internal::query_create_schema_part& part ) { +void query_builder::visit(internal::query_create_schema_part& part) { query_.command = sql::sql_command::CreateSchema; query_.sql += " " + dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema()); } -void query_builder::visit(internal::query_drop_part &part) { +void query_builder::visit(internal::query_drop_part& part) { query_.command = sql::sql_command::DropTable; query_.sql = dialect_->token_at(part.token()); } -void query_builder::visit( internal::query_drop_schema_part& part ) { +void query_builder::visit(internal::query_drop_schema_part& part) { query_.sql += " " + dialect_->drop() + " " + dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema()); } -void query_builder::visit(internal::query_set_part &part) { +void query_builder::visit(internal::query_set_part& part) { query_.sql += " " + dialect_->set() + " "; attribute_string_writer writer(*dialect_, connection_); @@ -354,10 +356,10 @@ void query_builder::visit(internal::query_set_part &part) { bool first = true; for (const auto& column_value : part.column_values()) { if (!first) { - query_.sql.append(", "); + query_.sql.append(", "); } query_.sql.append(dialect_->prepare_identifier_string(column_value.col().name()) + "="); - query_.sql.append(determine_value(*dialect_,query_, column_value.expression())); + query_.sql.append(determine_value(*dialect_, query_, column_value.expression())); first = false; } @@ -385,12 +387,12 @@ void query_builder::visit(internal::query_drop_sequence_part& part) { query_.sql += " " + dialect_->sequence() + " " + dialect_->prepare_identifier_string(part.sequence_name()); } -void query_builder::visit(internal::query_drop_table_part &part) { +void query_builder::visit(internal::query_drop_table_part& part) { query_.table_name = part.table().name(); query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name); } -void build_create_column(std::string &out, const table_column &col, const sql::dialect &d) { +void build_create_column(std::string& out, const table_column& col, const sql::dialect& d) { prepare_identifier_string_append(out, col.canonical_name(), d); out += " " + d.data_type_at(col.type()); if (col.attributes().size() > 0) { @@ -410,7 +412,7 @@ void build_create_column(std::string &out, const table_column &col, const sql::d } } -void build_columns_with_name_only(std::string &out, const std::vector &cols, const sql::dialect &d) { +void build_columns_with_name_only(std::string& out, const std::vector& cols, const sql::dialect& d) { bool first = true; for (const auto& col : cols) { if (!first) { @@ -421,7 +423,7 @@ void build_columns_with_name_only(std::string &out, const std::vector &cols, const sql::dialect &d) { +void build_columns(std::string& out, const std::vector& cols, const sql::dialect& d) { bool first = true; for (const auto& col : cols) { if (!first) { @@ -432,7 +434,7 @@ void build_columns(std::string &out, const std::vector &cols, con } } -void build_fetchable_columns(sql::query_context &ctx, const std::vector &cols, const sql::dialect &d) { +void build_fetchable_columns(sql::query_context& ctx, const std::vector& cols, const sql::dialect& d) { bool first = true; for (const auto& col : cols) { if (!first) { @@ -444,7 +446,7 @@ void build_fetchable_columns(sql::query_context &ctx, const std::vector &prototype, const table_column &col) { +void prepare_prototype(std::vector& prototype, const table_column& col) { if (col.is_function()) { prototype.emplace_back(col.has_alias() ? col.alias() : col.canonical_name()); prototype.back().change_type(utils::basic_type::Int32); @@ -454,60 +456,62 @@ void prepare_prototype(std::vector &prototype, const table_co } 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(" "); - } - if (cons.is_primary_key_constraint()) { - result - .append(d.primary_key()) - .append(" (") - .append(cons.column_name()) - .append(")"); - } else if (cons.is_foreign_key_constraint()) { - result - .append(d.foreign_key()) - .append(" (") - .append(cons.column_name()) - .append(") ") - .append(d.references()).append(" ") - .append(cons.referenced_table()) - .append(" (") - .append(cons.referenced_column()) - .append(")"); - } else { - // handle error - } - return result; + std::string result; + if (!cons.name().empty()) { + result.append(d.constraint()).append(" ").append(cons.name()).append(" "); + } + if (cons.is_primary_key_constraint()) { + result + .append(d.primary_key()) + .append(" (") + .append(cons.column_name()) + .append(")"); + } else if (cons.is_foreign_key_constraint()) { + result + .append(d.foreign_key()) + .append(" (") + .append(cons.column_name()) + .append(") ") + .append(d.references()).append(" ") + .append(cons.referenced_table()) + .append(" (") + .append(cons.referenced_column()) + .append(")"); + } else { + // handle error + } + return result; } -std::string query_builder::build_table_name(const sql::dialect_token token, const sql::dialect &d, const table& t) { +std::string query_builder::build_table_name(const sql::dialect_token token, const sql::dialect& d, const table& t) { return d.token_at(token) + " " + build_table_name(d, t); } -std::string query_builder::build_table_name(const sql::dialect &d, const table& t) { +std::string query_builder::build_table_name(const sql::dialect& d, const table& t) { return (!d.default_schema_name().empty() ? d.prepare_identifier_string(d.default_schema_name()) + "." : "") + d.prepare_identifier_string(t.table_name()) + (!t.has_alias() ? "" : " " + d.prepare_identifier_string(t.name())); } -std::string query_builder::build_add_constraint_string(const table_constraint &c) const { +std::string query_builder::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(")"); } else if (c.is_foreign_key_constraint()) { - result.append(dialect_->foreign_key()).append(" (").append(c.column_name()).append(") ").append(dialect_->references()).append(" ").append(c.referenced_table()).append(" (").append(c.referenced_column()).append(")"); + result.append(dialect_->foreign_key()).append(" (").append(c.column_name()).append(") "). + append(dialect_->references()).append(" ").append(c.referenced_table()).append(" (").append( + c.referenced_column()).append(")"); } else if (c.is_unique_constraint()) { result.append(dialect_->unique()).append(" (").append(c.column_name()).append(")"); } return result; } -std::string query_builder::build_drop_constraint_string(const table_constraint &c) const { +std::string query_builder::build_drop_constraint_string(const table_constraint& c) const { return dialect_->drop_constraint() + " " + build_constraint_name(c); } -std::string query_builder::build_constraint_name(const table_constraint &c) { +std::string query_builder::build_constraint_name(const table_constraint& c) { if (c.is_primary_key_constraint()) { return "PK_" + c.table_name(); }