sascha
/
query
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

some code formatting

This commit is contained in:
sascha 2026-03-19 11:54:50 +01:00
parent 6b2db17f58
commit 907bcf90a6
2 changed files with 116 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
source/orm/query/query_builder.cpp
View File

@ -17,16 +17,15 @@
#include "matador/sql/dialect.hpp" #include "matador/sql/dialect.hpp"
namespace matador::query { namespace matador::query {
sql::query_context query_builder::compile(const query_data& data,
sql::query_context query_builder::compile(const query_data &data, const sql::dialect& d,
const sql::dialect &d, const std::optional<std::reference_wrapper<const sql::connection_impl>>
const std::optional<std::reference_wrapper<const sql::connection_impl>> conn) conn) {
{
data_ = &data; data_ = &data;
dialect_ = &d; dialect_ = &d;
connection_ = conn; connection_ = conn;
query_ = {}; query_ = {};
for (const auto &part: data.parts) { for (const auto& part : data.parts) {
part->accept(*this); part->accept(*this);
} }
finisher_(query_); finisher_(query_);
@ -37,10 +36,10 @@ sql::query_context query_builder::compile(const query_data &data,
return {query_}; return {query_};
} }
void build_columns_with_name_only(std::string &out, const std::vector<table_column> &cols, const sql::dialect &d); void build_columns_with_name_only(std::string& out, const std::vector<table_column>& cols, const sql::dialect& d);
void build_columns(std::string &out, const std::vector<table_column> &cols, const sql::dialect &d); void build_columns(std::string& out, const std::vector<table_column>& cols, const sql::dialect& d);
void build_fetchable_columns(sql::query_context &ctx, const std::vector<table_column> &cols, const sql::dialect &d); void build_fetchable_columns(sql::query_context& ctx, const std::vector<table_column>& cols, const sql::dialect& d);
void prepare_prototype(std::vector<object::attribute> &prototype, const table_column &col); void prepare_prototype(std::vector<object::attribute>& prototype, const table_column& col);
void query_builder::visit(internal::query_alter_part& part) { void query_builder::visit(internal::query_alter_part& part) {
query_.sql = dialect_->token_at(part.token()); query_.sql = dialect_->token_at(part.token());
@ -74,7 +73,7 @@ void query_builder::visit(internal::query_add_foreign_key_reference_part& part)
query_.sql += ")"; 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()); 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()); 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_.command = sql::sql_command::Select;
query_.sql = dialect_->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()); 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_.table_name = part.tables().front().name();
query_.sql += " " + dialect_->from() + " "; query_.sql += " " + dialect_->from() + " ";
if (const auto &tables = part.tables(); tables.size() < 2) { if (const auto& tables = part.tables(); tables.size() < 2) {
for (const auto &tab: tables) { for (const auto& tab : tables) {
query_.sql += build_table_name(*dialect_, tab); query_.sql += build_table_name(*dialect_, tab);
} }
} else { } 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()); 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_) + ")"; 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_); criteria_evaluator evaluator(*dialect_, query_);
query_.sql += " " + dialect_->on() + 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_); criteria_evaluator evaluator(*dialect_, query_);
query_.sql += " " + dialect_->where() + 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() + " "; query_.sql += " " + dialect_->group_by() + " ";
if (part.columns().size() < 2) { 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())); query_.sql.append(dialect_->prepare_identifier_string(col.name()));
} }
} else { } 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() + " "; query_.sql += " " + dialect_->order_by() + " ";
if (part.columns().size() < 2) { 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())); query_.sql.append(dialect_->prepare_identifier_string(col.canonical_name()));
} }
} else { } else {
@ -178,28 +177,28 @@ 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(); 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(); 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()); 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()); 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_.command = sql::sql_command::Insert;
query_.sql = dialect_->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_.table_name = part.table().name();
query_.sql += " " + dialect_->into() + query_.sql += " " + dialect_->into() +
" " + dialect_->prepare_identifier_string(part.table().name()) + " ("; " " + dialect_->prepare_identifier_string(part.table().name()) + " (";
@ -208,23 +207,28 @@ void query_builder::visit(internal::query_into_part &part) {
query_.sql += ")"/* + result*/; query_.sql += ")"/* + result*/;
} }
struct value_visitor { struct value_visitor
value_visitor(attribute_string_writer &w, sql::query_context &ctx) {
: value_to_string_visitor(w, ctx) {} 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);
} }
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)); void operator()(const utils::database_type& val) {
value_to_string_visitor.result = value_to_string_visitor.writer->dialect().next_placeholder(value_to_string_visitor.query.bind_vars); 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; 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) { std::string query_builder::determine_value(const sql::dialect& d, sql::query_context& ctx,
const abstract_column_expression& exp) {
attribute_string_writer writer(d, {}); attribute_string_writer writer(d, {});
expression_evaluator v(d, ctx); expression_evaluator v(d, ctx);
exp.accept(v); exp.accept(v);
@ -232,12 +236,13 @@ std::string query_builder::determine_value(const sql::dialect &d, sql::query_con
return v.result(); return v.result();
} }
std::string query_builder::determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val) { std::string query_builder::determine_value(value_visitor& visitor,
const std::variant<utils::placeholder, utils::database_type>& val) {
std::visit(visitor, val); std::visit(visitor, val);
return visitor.value_to_string_visitor.result; 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(); query_.sql += " " + dialect_->values();
attribute_string_writer writer(*dialect_, connection_); attribute_string_writer writer(*dialect_, connection_);
@ -245,7 +250,7 @@ void query_builder::visit(internal::query_values_part &part) {
value_visitor visitor(writer, query_); value_visitor visitor(writer, query_);
std::string result{"("}; std::string result{"("};
if (part.values().size() < 2) { if (part.values().size() < 2) {
for (const auto& val: part.values()) { for (const auto& val : part.values()) {
result.append(determine_value(visitor, val)); result.append(determine_value(visitor, val));
} }
} else { } else {
@ -263,45 +268,42 @@ void query_builder::visit(internal::query_values_part &part) {
query_.sql += " " + result; 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_.mode = sql::return_mode::Rows;
query_.sql += " " + dialect_->returning() + " "; query_.sql += " " + dialect_->returning() + " ";
build_fetchable_columns(query_, part.columns(), *dialect_); 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_.command = sql::sql_command::Update;
query_.table_name = part.table().name(); query_.table_name = part.table().name();
query_.sql += build_table_name(part.token(), *dialect_, query_.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_.command = sql::sql_command::Delete;
query_.sql = dialect_->remove(); 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_.table_name = part.table().name();
query_.sql += " " + build_table_name(part.token(), *dialect_, query_.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_.command = sql::sql_command::CreateTable;
query_.sql = dialect_->create(); query_.sql = dialect_->create();
} }
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);
std::string build_constraint(const table_constraint &cons, 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_.sql += " " + dialect_->table() + " " + dialect_->prepare_identifier_string(part.table().name()) + " (";
query_.table_name = 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) { 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()); 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_.command = sql::sql_command::CreateSchema;
query_.sql += " " + dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema()); 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_.command = sql::sql_command::DropTable;
query_.sql = dialect_->token_at(part.token()); 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() + " " + query_.sql += " " + dialect_->drop() + " " +
dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema()); 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() + " "; query_.sql += " " + dialect_->set() + " ";
attribute_string_writer writer(*dialect_, connection_); attribute_string_writer writer(*dialect_, connection_);
@ -357,7 +359,7 @@ void query_builder::visit(internal::query_set_part &part) {
query_.sql.append(", "); query_.sql.append(", ");
} }
query_.sql.append(dialect_->prepare_identifier_string(column_value.col().name()) + "="); 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; 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()); 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_.table_name = part.table().name();
query_.sql += " " + build_table_name(part.token(), *dialect_, query_.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); prepare_identifier_string_append(out, col.canonical_name(), d);
out += " " + d.data_type_at(col.type()); out += " " + d.data_type_at(col.type());
if (col.attributes().size() > 0) { 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<table_column> &cols, const sql::dialect &d) { void build_columns_with_name_only(std::string& out, const std::vector<table_column>& cols, const sql::dialect& d) {
bool first = true; bool first = true;
for (const auto& col : cols) { for (const auto& col : cols) {
if (!first) { if (!first) {
@ -421,7 +423,7 @@ void build_columns_with_name_only(std::string &out, const std::vector<table_colu
} }
} }
void build_columns(std::string &out, const std::vector<table_column> &cols, const sql::dialect &d) { void build_columns(std::string& out, const std::vector<table_column>& cols, const sql::dialect& d) {
bool first = true; bool first = true;
for (const auto& col : cols) { for (const auto& col : cols) {
if (!first) { if (!first) {
@ -432,7 +434,7 @@ void build_columns(std::string &out, const std::vector<table_column> &cols, con
} }
} }
void build_fetchable_columns(sql::query_context &ctx, const std::vector<table_column> &cols, const sql::dialect &d) { void build_fetchable_columns(sql::query_context& ctx, const std::vector<table_column>& cols, const sql::dialect& d) {
bool first = true; bool first = true;
for (const auto& col : cols) { for (const auto& col : cols) {
if (!first) { if (!first) {
@ -444,7 +446,7 @@ void build_fetchable_columns(sql::query_context &ctx, const std::vector<table_co
} }
} }
void prepare_prototype(std::vector<object::attribute> &prototype, const table_column &col) { void prepare_prototype(std::vector<object::attribute>& prototype, const table_column& col) {
if (col.is_function()) { if (col.is_function()) {
prototype.emplace_back(col.has_alias() ? col.alias() : col.canonical_name()); prototype.emplace_back(col.has_alias() ? col.alias() : col.canonical_name());
prototype.back().change_type(utils::basic_type::Int32); prototype.back().change_type(utils::basic_type::Int32);
@ -481,33 +483,35 @@ std::string build_constraint(const table_constraint& cons, const sql::dialect& d
return result; 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); 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()) + "." : "") + return (!d.default_schema_name().empty() ? d.prepare_identifier_string(d.default_schema_name()) + "." : "") +
d.prepare_identifier_string(t.table_name()) + d.prepare_identifier_string(t.table_name()) +
(!t.has_alias() ? "" : " " + d.prepare_identifier_string(t.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) + " "; std::string result = " " + dialect_->add_constraint() + " " + build_constraint_name(c) + " ";
if (c.is_primary_key_constraint()) { if (c.is_primary_key_constraint()) {
result.append(dialect_->primary_key()).append(" (").append(c.column_name()).append(")"); result.append(dialect_->primary_key()).append(" (").append(c.column_name()).append(")");
} else if (c.is_foreign_key_constraint()) { } 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()) { } else if (c.is_unique_constraint()) {
result.append(dialect_->unique()).append(" (").append(c.column_name()).append(")"); result.append(dialect_->unique()).append(" (").append(c.column_name()).append(")");
} }
return result; 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); 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()) { if (c.is_primary_key_constraint()) {
return "PK_" + c.table_name(); return "PK_" + c.table_name();
} }