430 lines
14 KiB
C++
430 lines
14 KiB
C++
#include "matador/query/query_compiler.hpp"
|
|
|
|
#include "matador/query/attribute_string_writer.hpp"
|
|
#include "matador/query/query_data.hpp"
|
|
#include "matador/query/criteria_evaluator.hpp"
|
|
#include "matador/query/query_utils.hpp"
|
|
|
|
#include "matador/query/internal/basic_type_to_string_visitor.hpp"
|
|
#include "matador/query/internal/query_parts.hpp"
|
|
|
|
#include "matador/sql/query_context.hpp"
|
|
#include "matador/sql/connection.hpp"
|
|
#include "matador/sql/dialect.hpp"
|
|
|
|
#include "matador/utils/string.hpp"
|
|
|
|
namespace matador::query {
|
|
|
|
sql::query_context query_compiler::compile(const query_data &data,
|
|
const sql::dialect &d,
|
|
const std::optional<std::reference_wrapper<const sql::connection_impl>> conn)
|
|
{
|
|
data_ = &data;
|
|
dialect_ = &d;
|
|
connection_ = conn;
|
|
query_ = {};
|
|
for (const auto &part: data.parts) {
|
|
part->accept(*this);
|
|
}
|
|
finisher_(query_);
|
|
connection_ = std::nullopt;
|
|
dialect_ = nullptr;
|
|
data_ = nullptr;
|
|
|
|
return {query_};
|
|
}
|
|
|
|
std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const column &col) {
|
|
if (col.is_function()) {
|
|
ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.column_name());
|
|
ctx.prototype.back().change_type(utils::basic_type::type_int32);
|
|
} else {
|
|
ctx.prototype.emplace_back(col.column_name());
|
|
}
|
|
|
|
if (const auto it = data.tables.find(col.table()->name()); it != data.tables.end()) {
|
|
return prepare_identifier(*d, {it->second, col.column_name(), col.alias()});
|
|
}
|
|
|
|
return prepare_identifier(*d, col);
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_alter_part& part) {
|
|
query_.sql = dialect_->token_at(part.token());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_alter_table_part& part) {
|
|
query_.command = sql::sql_command::SQL_ALTER_TABLE;
|
|
query_.sql += " " + dialect_->token_at(part.token()) + " " +
|
|
dialect_->prepare_identifier_string(part.table().name());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_add_key_constraint_part& part) {
|
|
query_.sql += " " + dialect_->add_constraint() + " " + part.name();
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_add_foreign_key_constraint_part& part) {
|
|
query_.sql += " " + dialect_->token_at(part.token()) + " (";
|
|
|
|
if (part.columns().size() < 2) {
|
|
for (const auto &col: part.columns()) {
|
|
query_.sql += dialect_->prepare_identifier_string(col.column_name());
|
|
}
|
|
} else {
|
|
auto it = part.columns().begin();
|
|
query_.sql += dialect_->prepare_identifier_string(it->column_name());
|
|
for (; it != part.columns().end(); ++it) {
|
|
query_.sql += ", " + dialect_->prepare_identifier_string(it->column_name());
|
|
}
|
|
}
|
|
query_.sql += ")";
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_add_primary_key_constraint_part& part) {
|
|
query_.sql += " " + dialect_->primary_key() + " (";
|
|
|
|
if (part.columns().size() < 2) {
|
|
for (const auto &col: part.columns()) {
|
|
query_.sql += dialect_->prepare_identifier_string(col.column_name());
|
|
}
|
|
} else {
|
|
auto it = part.columns().begin();
|
|
query_.sql += dialect_->prepare_identifier_string(it->column_name());
|
|
for (; it != part.columns().end(); ++it) {
|
|
query_.sql += ", " + dialect_->prepare_identifier_string(it->column_name());
|
|
}
|
|
}
|
|
query_.sql += ")";
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_add_foreign_key_reference_part& part) {
|
|
query_.sql += " " + dialect_->token_at(part.token()) + " " + part.table().name() + " (";
|
|
|
|
if (part.columns().size() < 2) {
|
|
for (const auto &col: part.columns()) {
|
|
query_.sql += dialect_->prepare_identifier_string(col.column_name());
|
|
}
|
|
} else {
|
|
auto it = part.columns().begin();
|
|
query_.sql += dialect_->prepare_identifier_string(it->column_name());
|
|
for (; it != part.columns().end(); ++it) {
|
|
query_.sql += ", " + dialect_->prepare_identifier_string(it->column_name());
|
|
}
|
|
}
|
|
query_.sql += ")";
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_drop_key_constraint_part& part) {
|
|
query_.sql += " " + dialect_->token_at(part.token()) + " " + part.name();
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_drop_foreign_key_constraint_part& part) {
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_select_part &part) {
|
|
query_.command = sql::sql_command::SQL_SELECT;
|
|
query_.sql = dialect_->select() + " ";
|
|
|
|
query_.prototype.clear();
|
|
|
|
std::string result;
|
|
if (part.columns().empty()) {
|
|
result = dialect_->asterisk();
|
|
} else if (const auto &columns = part.columns(); columns.size() < 2) {
|
|
for (const auto &col: columns) {
|
|
result.append(handle_column(query_, dialect_, *data_, col ));
|
|
}
|
|
} else {
|
|
auto it = columns.begin();
|
|
result.append(handle_column(query_, dialect_, *data_, *it++));
|
|
for (; it != columns.end(); ++it) {
|
|
result.append(", ");
|
|
result.append(handle_column(query_, dialect_, *data_, *it));
|
|
}
|
|
}
|
|
|
|
query_.sql += result;
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_from_part &part) {
|
|
query_.table_name = part.table().name();
|
|
query_.sql += " " + build_table_name(part.token(), *dialect_, part.table());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_join_part &part)
|
|
{
|
|
query_.sql += " " + build_table_name(part.token(), *dialect_, part.table());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_on_part &part) {
|
|
criteria_evaluator evaluator(*dialect_, query_);
|
|
query_.sql += " " + dialect_->on() +
|
|
" " + evaluator.evaluate(part.condition());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_where_part &part) {
|
|
criteria_evaluator evaluator(*dialect_, query_);
|
|
query_.sql += " " + dialect_->where() +
|
|
" " + evaluator.evaluate(part.condition());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_group_by_part &part) {
|
|
query_.sql += " " + dialect_->group_by() + " " + prepare_identifier(*dialect_, part.column());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_order_by_part &part) {
|
|
query_.sql += " " + dialect_->order_by() +
|
|
" " + prepare_criteria(*dialect_, part.column());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_order_by_asc_part &/*order_by_asc_part*/) {
|
|
query_.sql += " " + dialect_->asc();
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_order_by_desc_part &/*order_by_desc_part*/) {
|
|
query_.sql += " " + dialect_->desc();
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_offset_part &part) {
|
|
query_.sql += " " + dialect_->offset() + " " + std::to_string(part.offset());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_limit_part &part) {
|
|
query_.sql += " " + dialect_->limit() + " " + std::to_string(part.limit());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_insert_part &/*insert_part*/) {
|
|
query_.command = sql::sql_command::SQL_INSERT;
|
|
query_.sql = dialect_->insert();
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_into_part &part) {
|
|
query_.table_name = part.table().name();
|
|
query_.sql += " " + dialect_->into() +
|
|
" " + dialect_->prepare_identifier_string(part.table().name());
|
|
|
|
std::string result{"("};
|
|
if (part.columns().size() < 2) {
|
|
for (const auto &col: part.columns()) {
|
|
result.append(dialect_->prepare_identifier_string(col.column_name()));
|
|
}
|
|
} else {
|
|
auto it = part.columns().begin();
|
|
result.append(dialect_->prepare_identifier_string((it++)->column_name()));
|
|
for (; it != part.columns().end(); ++it) {
|
|
result.append(", ");
|
|
result.append(dialect_->prepare_identifier_string(it->column_name()));
|
|
}
|
|
}
|
|
result += (")");
|
|
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);
|
|
|
|
}
|
|
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_compiler::determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val) {
|
|
std::visit(visitor, val);
|
|
return visitor.value_to_string_visitor.result;
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_values_part &part) {
|
|
query_.sql += " " + dialect_->values();
|
|
|
|
attribute_string_writer writer(*dialect_, connection_);
|
|
|
|
value_visitor visitor(writer, query_);
|
|
std::string result{"("};
|
|
if (part.values().size() < 2) {
|
|
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));
|
|
for (; it != part.values().end(); ++it) {
|
|
result.append(", ");
|
|
val = *it;
|
|
result.append(determine_value(visitor, val));
|
|
}
|
|
}
|
|
result += (")");
|
|
|
|
query_.sql += " " + result;
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_update_part &part)
|
|
{
|
|
query_.command = sql::sql_command::SQL_UPDATE;
|
|
query_.table_name = part.table().name();
|
|
query_.sql += query_compiler::build_table_name(part.token(), *dialect_, query_.table_name);
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_delete_part &/*delete_part*/)
|
|
{
|
|
query_.command = sql::sql_command::SQL_DELETE;
|
|
query_.sql = dialect_->remove();
|
|
}
|
|
|
|
void query_compiler::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_compiler::visit(internal::query_create_part &/*create_part*/)
|
|
{
|
|
query_.command = sql::sql_command::SQL_CREATE_TABLE;
|
|
query_.sql = dialect_->create();
|
|
}
|
|
|
|
std::string build_create_column(const object::attribute &col, const sql::dialect &d);
|
|
std::string build_constraint(const class object::constraint &cons, const sql::dialect &d);
|
|
|
|
void query_compiler::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 += ")"; };
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_create_table_columns_part& part) {
|
|
std::string result;
|
|
|
|
if (part.columns().size() < 2) {
|
|
for (const auto &col: part.columns()) {
|
|
result.append(build_create_column(col, *dialect_));
|
|
}
|
|
} else {
|
|
auto it = part.columns().begin();
|
|
result.append(build_create_column(*it++, *dialect_));
|
|
for (; it != part.columns().end(); ++it) {
|
|
result.append(", ");
|
|
result.append(build_create_column(*it, *dialect_));
|
|
}
|
|
}
|
|
|
|
query_.sql += result;
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_create_table_constraints_part& part) {
|
|
std::string result;
|
|
for (const auto& c : part.constraints()) {
|
|
result.append(", ");
|
|
result.append(build_constraint(c, *dialect_));
|
|
}
|
|
query_.sql += result;
|
|
}
|
|
|
|
void query_compiler::visit( internal::query_create_schema_part& part ) {
|
|
query_.sql += " " + dialect_->create() + " " +
|
|
dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_drop_part &part) {
|
|
query_.command = sql::sql_command::SQL_DROP_TABLE;
|
|
query_.sql = dialect_->token_at(part.token());
|
|
}
|
|
|
|
void query_compiler::visit( internal::query_drop_schema_part& part ) {
|
|
query_.sql += " " + dialect_->drop() + " " +
|
|
dialect_->schema() + " " + dialect_->prepare_identifier_string(part.schema());
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_set_part &part) {
|
|
query_.sql += " " + dialect_->set() + " ";
|
|
|
|
attribute_string_writer writer(*dialect_, connection_);
|
|
std::string result;
|
|
|
|
value_visitor visitor(writer, query_); if (part.column_values().size() < 2) {
|
|
for (const auto &column_value: part.column_values()) {
|
|
result.append(dialect_->prepare_identifier_string(column_value.col().column_name()) + "=");
|
|
result.append(determine_value(visitor, column_value.value()));
|
|
}
|
|
} else {
|
|
auto it = part.column_values().begin();
|
|
result.append(dialect_->prepare_identifier_string(it->col().column_name()) + "=");
|
|
result.append(determine_value(visitor, (it++)->value()));
|
|
for (; it != part.column_values().end(); ++it) {
|
|
result.append(", ");
|
|
result.append(dialect_->prepare_identifier_string(it->col().column_name()) + "=");
|
|
result.append(determine_value(visitor, it->value()));
|
|
}
|
|
}
|
|
|
|
query_.sql += result;
|
|
}
|
|
|
|
void query_compiler::visit(internal::query_drop_table_part &part) {
|
|
query_.table_name = part.table().name();
|
|
query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
|
|
}
|
|
|
|
std::string build_create_column(const object::attribute &col, const sql::dialect &d) {
|
|
std::string result = d.prepare_identifier_string(col.name()) + " " + d.data_type_at(col.type());
|
|
if (col.attributes().size() > 0) {
|
|
result.append("(" + std::to_string(col.attributes().size()) + ")");
|
|
}
|
|
if (!col.is_nullable()) {
|
|
result.append(" NOT NULL");
|
|
}
|
|
if (is_constraint_set(col.attributes().options(), utils::constraints::Unique)) {
|
|
result.append(" UNIQUE");
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
std::string build_constraint(const class object::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.ref_table_name())
|
|
.append(" (")
|
|
.append(cons.ref_column_name())
|
|
.append(")");
|
|
} else {
|
|
// handle error
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::string query_compiler::build_table_name(const sql::dialect_token token, const sql::dialect &d, const table& t) {
|
|
return d.token_at(token) + " " +
|
|
(!d.default_schema_name().empty() ? d.prepare_identifier_string(d.default_schema_name()) + "." : "") +
|
|
d.prepare_identifier_string(t.name()) +
|
|
(t.alias().empty() ? "" : " " + d.prepare_identifier_string(t.alias()));
|
|
}
|
|
|
|
} |