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

moved column and table class from namespace sql to query

Browse Source
This commit is contained in:
Sascha Kühl
2025-11-18 16:27:38 +01:00
parent 7242dc2612
commit fb4bc03da0
79 changed files with 626 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/orm/CMakeLists.txt
+11 -7
View File
@@ -4,6 +4,8 @@ add_library(matador-orm STATIC
../../include/matador/orm/session.hpp
../../include/matador/orm/session_query_builder.hpp
../../include/matador/query/attribute_string_writer.hpp
../../include/matador/query/builder.hpp
../../include/matador/query/column.hpp
../../include/matador/query/criteria.hpp
../../include/matador/query/criteria/abstract_column_criteria.hpp
../../include/matador/query/criteria/abstract_criteria.hpp
@@ -16,6 +18,7 @@ add_library(matador-orm STATIC
../../include/matador/query/criteria/logical_criteria.hpp
../../include/matador/query/criteria_evaluator.hpp
../../include/matador/query/fk_value_extractor.hpp
../../include/matador/query/generator.hpp
../../include/matador/query/intermediates/executable_query.hpp
../../include/matador/query/intermediates/fetchable_query.hpp
../../include/matador/query/intermediates/query_alter_intermediate.hpp
@@ -53,10 +56,11 @@ add_library(matador-orm STATIC
../../include/matador/query/query_data.hpp
../../include/matador/query/query_intermediates.hpp
../../include/matador/query/query_part.hpp
../../include/matador/query/query_utils.hpp
../../include/matador/query/table.hpp
../../include/matador/query/value_extractor.hpp
../../include/matador/sql/abstract_sql_logger.hpp
../../include/matador/sql/backend_provider.hpp
../../include/matador/sql/column.hpp
../../include/matador/sql/connection.hpp
../../include/matador/sql/connection_info.hpp
../../include/matador/sql/dialect.hpp
@@ -77,14 +81,16 @@ add_library(matador-orm STATIC
../../include/matador/sql/query_macro.hpp
../../include/matador/sql/query_result.hpp
../../include/matador/sql/record.hpp
../../include/matador/sql/sql_functions.hpp
../../include/matador/sql/statement.hpp
../../include/matador/sql/table.hpp
orm/error_code.cpp
orm/query_builder_exception.cpp
orm/schema.cpp
orm/session.cpp
orm/session_query_builder.cpp
query/attribute_string_writer.cpp
query/builder.cpp
query/column.cpp
query/criteria/abstract_column_criteria.cpp
query/criteria/between_criteria.cpp
query/criteria/binary_criteria.cpp
@@ -94,6 +100,7 @@ add_library(matador-orm STATIC
query/criteria/logical_criteria.cpp
query/criteria/not_criteria.cpp
query/criteria_evaluator.cpp
query/generator.cpp
query/intermediates/executable_query.cpp
query/intermediates/fetchable_query.cpp
query/intermediates/query_alter_intermediate.cpp
@@ -129,16 +136,16 @@ add_library(matador-orm STATIC
query/query.cpp
query/query_compiler.cpp
query/query_part.cpp
query/query_utils.cpp
query/table.cpp
query/value_extractor.cpp
sql/backend_provider.cpp
sql/column.cpp
sql/connection.cpp
sql/connection_info.cpp
sql/connection_pool.cpp
sql/dialect.cpp
sql/dialect_builder.cpp
sql/error_code.cpp
sql/executor.cpp
sql/field.cpp
sql/interface/connection_impl.cpp
sql/interface/query_result_reader.cpp
@@ -151,9 +158,6 @@ add_library(matador-orm STATIC
sql/record.cpp
sql/statement.cpp
sql/statement_cache.cpp
sql/table.cpp
../../include/matador/query/generator.hpp
query/generator.cpp
)
target_include_directories(matador-orm
source/orm/orm/session.cpp
+4 -4
View File
@@ -90,13 +90,13 @@ utils::result<sql::query_result<sql::record>, utils::error> session::fetch_all(c
if (!c.valid()) {
return utils::failure(make_error(error_code::NoConnectionAvailable, "Failed to acquire connection."));
}
auto it = prototypes_.find(q.table.name());
auto it = prototypes_.find(q.table_name);
if (it == prototypes_.end()) {
auto result = c->describe(q.table.name());
auto result = c->describe(q.table_name);
if (!result) {
return utils::failure(result.err());
}
it = prototypes_.emplace(q.table.name(), *result).first;
it = prototypes_.emplace(q.table_name, *result).first;
}
// adjust columns from given query
for (auto &col: q.prototype) {
@@ -175,7 +175,7 @@ query::fetchable_query session::build_select_query(entity_query_data &&data) {
.from(*data.root_table)
.join_left(data.joins)
.where(std::move(data.where_clause))
.order_by(sql::column{data.root_table, data.pk_column_name})
.order_by({data.root_table, data.pk_column_name})
.asc();
}
}
source/orm/orm/session_query_builder.cpp
+4 -4
View File
@@ -3,7 +3,7 @@
#include <iostream>
namespace matador::orm {
criteria_transformer::criteria_transformer(const object::repository& repo, const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name)
criteria_transformer::criteria_transformer(const object::repository& repo, const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name)
: repo_(repo)
, tables_by_name_(tables_by_name) {}
@@ -39,12 +39,12 @@ void criteria_transformer::visit( const query::not_criteria& node ) {
}
void criteria_transformer::update_criteria_column(const query::abstract_column_criteria& node) const {
const auto it = tables_by_name_.find(node.column().table()->name());
const auto it = tables_by_name_.find(node.col().table()->name());
if (it == tables_by_name_.end()) {
return;
}
const_cast<sql::column&>(node.column()).table(it->second);
const_cast<query::column&>(node.col()).table(it->second);
}
void session_query_builder::on_revision(const char *id, uint64_t &/*rev*/) {
@@ -70,7 +70,7 @@ std::string session_query_builder::build_alias(const char prefix, const unsigned
return table_info_stack_.size() == 1;
}
void session_query_builder::append_join(const sql::column &left, const sql::column &right) {
void session_query_builder::append_join(const query::column &left, const query::column &right) {
using namespace matador::query;
entity_query_data_.joins.push_back({
{right.table()},
source/orm/query/builder.cpp
+62
View File
@@ -0,0 +1,62 @@
#include "matador/query/builder.hpp"
namespace matador::query {
column_builder::column_builder(std::string column_name)
: column_name( std::move(column_name) ) {}
column_builder::operator class query::column() const {
return {column_name};
}
table_builder::table_builder(std::string name)
: table_name( std::move(name) ) {}
table_builder& table_builder::as( std::string table_alias ) {
this->alias = std::move(table_alias);
return *this;
}
table_builder::operator class query::table() const {
return {table_name, alias};
}
constraint_builder& constraint_builder::constraint( std::string name ) {
constraint_name = std::move(name);
return *this;
}
constraint_builder& constraint_builder::primary_key( std::string name ) {
pk_column_name = std::move(name);
return *this;
}
constraint_builder& constraint_builder::foreign_key( std::string name ) {
fk_column_name = std::move(name);
return *this;
}
constraint_builder& constraint_builder::references( std::string table, std::string column ) {
this->table_name = std::move(table);
this->column_name = std::move(column);
return *this;
}
constraint_builder::operator struct query::constraint() const {
return {constraint_name};
}
constraint_builder constraint( std::string name ) {
constraint_builder builder;
return builder.constraint(std::move(name));
}
table_builder table( std::string name ) {
return table_builder(std::move(name));
}
column_builder column( std::string name ) {
return column_builder(std::move(name));
}
}
source/orm/sql/column.cpp → source/orm/query/column.cpp
+12 -13
View File
@@ -1,12 +1,11 @@
#include "matador/sql/column.hpp"
#include "matador/query/column.hpp"
#include "matador/sql/table.hpp"
#include "matador/query/table.hpp"
#include <stdexcept>
#include <utility>
namespace matador::sql {
namespace matador::query {
column operator ""_col(const char *name, size_t len) {
const std::string str(name, len);
@@ -27,23 +26,23 @@ column::column(const char *name, const std::string& as)
{}
column::column(std::string name, std::string as)
: table_(std::make_shared<sql::table>())
: table_(std::make_shared<query::table>())
, name(std::move(name))
, alias_(std::move(as)) {}
column::column(const sql_function_t func, std::string name)
: table_(std::make_shared<sql::table>())
column::column(const sql::sql_function_t func, std::string name)
: table_(std::make_shared<query::table>())
, name(std::move(name))
, function_(func) {}
column::column(const sql::table& tab, std::string name, std::string as)
: table_(std::make_shared<sql::table>(tab))
column::column(const query::table& tab, std::string name, std::string as)
: table_(std::make_shared<query::table>(tab))
, name(std::move(name))
, alias_(std::move(as)) {
table_->columns_.push_back(*this);
}
column::column(const std::shared_ptr<sql::table>& t, std::string name, std::string as)
column::column(const std::shared_ptr<query::table>& t, std::string name, std::string as)
: table_(t)
, name(std::move(name))
, alias_(std::move(as)) {
@@ -77,10 +76,10 @@ const std::string& column::alias_name() const {
}
bool column::is_function() const {
return function_ != sql_function_t::None;
return function_ != sql::sql_function_t::None;
}
sql_function_t column::function() const {
sql::sql_function_t column::function() const {
return function_;
}
@@ -96,7 +95,7 @@ std::shared_ptr<table> column::table() const {
return table_;
}
void column::table( const std::shared_ptr<sql::table>& t ) {
void column::table( const std::shared_ptr<query::table>& t ) {
table_ = t;
}
}
source/orm/query/criteria/abstract_column_criteria.cpp
+3 -3
View File
@@ -1,10 +1,10 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
namespace matador::query {
abstract_column_criteria::abstract_column_criteria(sql::column column)
: column_(std::move(column)) {}
abstract_column_criteria::abstract_column_criteria(column col)
: column_(std::move(col)) {}
const sql::column& abstract_column_criteria::column() const {
const column& abstract_column_criteria::col() const {
return column_;
}
}
source/orm/query/criteria/between_criteria.cpp
+4 -4
View File
@@ -3,14 +3,14 @@
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query{
between_criteria::between_criteria(sql::column column, const int64_t min, const int64_t max)
: abstract_column_criteria(std::move(column))
between_criteria::between_criteria(column col, const int64_t min, const int64_t max)
: abstract_column_criteria(std::move(col))
, min_(utils::value{min})
, max_(utils::value{max})
{}
between_criteria::between_criteria(sql::column column, utils::placeholder min, utils::placeholder max)
: abstract_column_criteria(std::move(column))
between_criteria::between_criteria(column col, utils::placeholder min, utils::placeholder max)
: abstract_column_criteria(std::move(col))
, min_(min)
, max_(max)
{}
source/orm/query/criteria/binary_criteria.cpp
+5 -5
View File
@@ -3,8 +3,8 @@
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
binary_criteria::binary_criteria(sql::column column, const binary_operator operand, criteria_value value)
: abstract_column_criteria(std::move(column))
binary_criteria::binary_criteria(column col, const binary_operator operand, criteria_value value)
: abstract_column_criteria(std::move(col))
, operator_(operand)
, value_(std::move(value))
{}
@@ -21,7 +21,7 @@ const criteria_value& binary_criteria::value() const {
return value_;
}
binary_column_criteria::binary_column_criteria( sql::column left_column, binary_operator operand, sql::column right_column )
binary_column_criteria::binary_column_criteria(column left_column, binary_operator operand, column right_column)
: left_column_(std::move(left_column))
, operator_(operand)
, right_column_(std::move(right_column)){}
@@ -30,7 +30,7 @@ void binary_column_criteria::accept(criteria_visitor& visitor) const {
visitor.visit(*this);
}
const sql::column& binary_column_criteria::left_column() const {
const column& binary_column_criteria::left_column() const {
return left_column_;
}
@@ -38,7 +38,7 @@ binary_operator binary_column_criteria::operand() const {
return operator_;
}
const sql::column& binary_column_criteria::right_column() const {
const column& binary_column_criteria::right_column() const {
return right_column_;
}
}
source/orm/query/criteria/collection_criteria.cpp
+3 -3
View File
@@ -3,13 +3,13 @@
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
collection_criteria::collection_criteria(sql::column col, const collection_operator operand_, std::vector<criteria_value> values )
collection_criteria::collection_criteria(column col, const collection_operator operand_, std::vector<criteria_value> values )
: abstract_column_criteria(std::move(col))
, operand_(operand_)
, values_(std::move(values))
{}
collection_criteria::collection_criteria(sql::column col, const collection_operator operand_, const std::initializer_list<criteria_value> values )
collection_criteria::collection_criteria(column col, const collection_operator operand_, const std::initializer_list<criteria_value> values )
: abstract_column_criteria(std::move(col))
, operand_(operand_)
, values_(values)
@@ -27,7 +27,7 @@ const std::vector<criteria_value>& collection_criteria::values() const {
return values_;
}
collection_query_criteria::collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx)
collection_query_criteria::collection_query_criteria(column col, collection_operator operand_, sql::query_context ctx)
: abstract_column_criteria(std::move(col))
, operand_(operand_)
, query_context_(std::move(ctx)){
source/orm/query/criteria/criteria_operators.cpp
+19 -19
View File
@@ -6,51 +6,51 @@
#include "matador/query/criteria/not_criteria.hpp"
namespace matador::query {
criteria_ptr operator==(const sql::column &col, utils::placeholder p) {
criteria_ptr operator==(const column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, p);
}
criteria_ptr operator!=(const sql::column &col, utils::placeholder p) {
criteria_ptr operator!=(const column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, p);
}
criteria_ptr operator>(const sql::column &col, utils::placeholder p) {
criteria_ptr operator>(const column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, p);
}
criteria_ptr operator>=(const sql::column &col, utils::placeholder p) {
criteria_ptr operator>=(const column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, p);
}
criteria_ptr operator<(const sql::column &col, utils::placeholder p) {
criteria_ptr operator<(const column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, p);
}
criteria_ptr operator<=(const sql::column &col, utils::placeholder p) {
criteria_ptr operator<=(const column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, p);
}
criteria_ptr operator==( const sql::column& col_left, const sql::column& col_right ) {
criteria_ptr operator==( const column& col_left, const column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::EQUALS, col_right);
}
criteria_ptr operator!=( const sql::column& col_left, const sql::column& col_right ) {
criteria_ptr operator!=( const column& col_left, const column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::NOT_EQUALS, col_right);
}
criteria_ptr operator>( const sql::column& col_left, const sql::column& col_right ) {
criteria_ptr operator>( const column& col_left, const column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN, col_right);
}
criteria_ptr operator>=( const sql::column& col_left, const sql::column& col_right ) {
criteria_ptr operator>=( const column& col_left, const column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN_OR_EQUAL, col_right);
}
criteria_ptr operator<( const sql::column& col_left, const sql::column& col_right ) {
criteria_ptr operator<( const column& col_left, const column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN, col_right);
}
criteria_ptr operator<=( const sql::column& col_left, const sql::column& col_right ) {
criteria_ptr operator<=( const column& col_left, const column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN_OR_EQUAL, col_right);
}
@@ -67,7 +67,7 @@ criteria_ptr operator!(criteria_ptr clause) {
}
template <>
criteria_ptr in(const sql::column &col, const std::initializer_list<utils::placeholder> args) {
criteria_ptr in(const column &col, const std::initializer_list<utils::placeholder> args) {
std::vector<criteria_value> values;
for ( auto &&arg : args ) {
values.emplace_back(arg);
@@ -75,12 +75,12 @@ criteria_ptr in(const sql::column &col, const std::initializer_list<utils::place
return std::make_unique<collection_criteria>(col, collection_operator::In, std::move(values));
}
criteria_ptr in(const sql::column &col, sql::query_context &&ctx) {
criteria_ptr in(const column &col, sql::query_context &&ctx) {
return std::make_unique<collection_query_criteria>(col, collection_operator::In, std::move(ctx));
}
template <>
criteria_ptr out(const sql::column &col, const std::initializer_list<utils::placeholder> args) {
criteria_ptr out(const column &col, const std::initializer_list<utils::placeholder> args) {
std::vector<criteria_value> values;
for ( auto &&arg : args ) {
values.emplace_back(arg);
@@ -88,19 +88,19 @@ criteria_ptr out(const sql::column &col, const std::initializer_list<utils::plac
return std::make_unique<collection_criteria>(col, collection_operator::Out, values);
}
criteria_ptr out(const sql::column &col, sql::query_context &&ctx) {
criteria_ptr out(const column &col, sql::query_context &&ctx) {
return std::make_unique<collection_query_criteria>(col, collection_operator::In, std::move(ctx));
}
criteria_ptr between(const sql::column &col, const int64_t min, const int64_t max) {
criteria_ptr between(const column &col, const int64_t min, const int64_t max) {
return std::make_unique<between_criteria>(col, min, max);
}
criteria_ptr between(const sql::column &col, utils::placeholder min, utils::placeholder max) {
criteria_ptr between(const column &col, utils::placeholder min, utils::placeholder max) {
return std::make_unique<between_criteria>(col, min, max);
}
criteria_ptr like(const sql::column &col, const std::string &pattern) {
criteria_ptr like(const column &col, const std::string &pattern) {
return std::make_unique<like_criteria>(col, pattern);
}
}
source/orm/query/criteria/like_criteria.cpp
+2 -2
View File
@@ -3,8 +3,8 @@
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
like_criteria::like_criteria(sql::column column, std::string pattern)
: abstract_column_criteria(std::move(column))
like_criteria::like_criteria(column col, std::string pattern)
: abstract_column_criteria(std::move(col))
, pattern_(std::move(pattern)){}
void like_criteria::accept(criteria_visitor &visitor) const {
source/orm/query/criteria_evaluator.cpp
+11 -10
View File
@@ -1,5 +1,6 @@
#include "matador/query/criteria_evaluator.hpp"
#include "matador/query/query_utils.hpp"
#include "matador/query/criteria/between_criteria.hpp"
#include "matador/query/criteria/binary_criteria.hpp"
#include "matador/query/criteria/collection_criteria.hpp"
@@ -38,9 +39,9 @@ std::string criteria_evaluator::evaluate(const abstract_criteria &node) {
}
void criteria_evaluator::visit(const between_criteria &node) {
query_.bind_vars.emplace_back(node.column().column_name());
query_.bind_vars.emplace_back(node.column().column_name());
clause_ += dialect_.prepare_identifier(node.column()) + " " + dialect_.token_at(sql::dialect_token::Between) + " ";
query_.bind_vars.emplace_back(node.col().column_name());
query_.bind_vars.emplace_back(node.col().column_name());
clause_ += prepare_identifier(dialect_, node.col()) + " " + dialect_.token_at(sql::dialect_token::Between) + " ";
evaluate_value(node.minimum());
clause_ += " " + dialect_.token_at(sql::dialect_token::And) + " ";
evaluate_value(node.maximum());
@@ -50,23 +51,23 @@ template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
template<class... Ts> overload(Ts...) -> overload<Ts...>;
void criteria_evaluator::visit(const binary_criteria &node) {
query_.bind_vars.emplace_back(node.column().column_name());
clause_ += dialect_.prepare_condition(node.column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " ";
query_.bind_vars.emplace_back(node.col().column_name());
clause_ += prepare_criteria(dialect_, node.col()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " ";
evaluate_value(node.value());
}
void criteria_evaluator::visit( const binary_column_criteria& node ) {
clause_ += dialect_.prepare_condition(node.left_column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " " + dialect_.prepare_condition(node.right_column());
clause_ += prepare_criteria(dialect_, node.left_column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " " + prepare_criteria(dialect_, node.right_column());
}
void criteria_evaluator::visit(const collection_criteria &node) {
const auto count = node.values().size();
for (size_t i = 0; i < count; ++i) {
query_.bind_vars.emplace_back(node.column().column_name());
query_.bind_vars.emplace_back(node.col().column_name());
}
clause_ += dialect_.prepare_identifier(node.column()) +
clause_ += prepare_identifier(dialect_, node.col()) +
(node.operand() == collection_operator::Out ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
dialect_.token_at(sql::dialect_token::In) + " (";
if (node.values().size() < 2) {
@@ -85,13 +86,13 @@ void criteria_evaluator::visit(const collection_criteria &node) {
}
void criteria_evaluator::visit(const collection_query_criteria &node) {
clause_ += dialect_.prepare_identifier(node.column()) +
clause_ += prepare_identifier(dialect_, node.col()) +
(node.operand() == collection_operator::Out ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
dialect_.token_at(sql::dialect_token::In) + " (" +node.context().sql + ")";
}
void criteria_evaluator::visit(const like_criteria &node) {
clause_ += dialect_.prepare_condition(node.column()) + " " + dialect_.token_at(sql::dialect_token::Like) +
clause_ += prepare_criteria(dialect_, node.col()) + " " + dialect_.token_at(sql::dialect_token::Like) +
" " + dialect_.token_at(sql::dialect_token::BeginStringData) + node.pattern() + dialect_.token_at(
sql::dialect_token::EndStringData);
}
source/orm/query/generator.cpp
+2 -2
View File
@@ -3,13 +3,13 @@
namespace matador::query::generator {
column_generator::column_generator( const std::string& table_name, const column_generator_options options)
: options_(options) {
table_stack_.push(table_name.empty() ? std::make_shared<sql::table>() : std::make_shared<sql::table>(table_name));
table_stack_.push(table_name.empty() ? std::make_shared<table>() : std::make_shared<table>(table_name));
}
column_generator::column_generator(const object::repository& repo, const std::string& table_name, const column_generator_options options)
: repo_(std::cref(repo))
, options_(options) {
table_stack_.push(table_name.empty() ? std::make_shared<sql::table>() : std::make_shared<sql::table>(table_name));
table_stack_.push(table_name.empty() ? std::make_shared<table>() : std::make_shared<table>(table_name));
}
void column_generator::on_revision( const char* id, uint64_t& ) {
source/orm/query/intermediates/query_alter_intermediate.cpp
+2 -2
View File
@@ -7,8 +7,8 @@ query_alter_intermediate::query_alter_intermediate() {
context_->parts.push_back(std::make_unique<internal::query_alter_part>());
}
query_alter_table_intermediate query_alter_intermediate::table( const sql::table& table ) const {
context_->parts.push_back(std::make_unique<internal::query_alter_table_part>(table));
query_alter_table_intermediate query_alter_intermediate::table(const class table& tab) const {
context_->parts.push_back(std::make_unique<internal::query_alter_table_part>(tab));
return {context_};
}
}
source/orm/query/intermediates/query_alter_table_intermediate.cpp
+8 -8
View File
@@ -3,27 +3,27 @@
#include "matador/query/internal/query_parts.hpp"
namespace matador::query {
executable_query query_add_foreign_key_constraint_intermediate::references( const sql::table& table, const std::vector<sql::column>& columns) {
context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_reference_part>(table, columns));
executable_query query_add_foreign_key_constraint_intermediate::references( const table& tab, const std::vector<column>& columns) {
context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_reference_part>(tab, columns));
return {context_};
}
query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const sql::column& column) const {
return primary_keys({column});
query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const column& col) const {
return primary_keys({col});
}
query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<sql::column>& columns ) const {
query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<column>& columns) const {
context_->parts.push_back(std::make_unique<internal::query_add_primary_key_constraint_part>(columns));
return {context_};
}
query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const sql::column& column) const {
return foreign_keys({column});
query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const column& col) const {
return foreign_keys({col});
}
query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys( const std::vector<sql::column>& columns ) const {
query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys(const std::vector<column>& columns) const {
context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_constraint_part>(columns));
return {context_};
source/orm/query/intermediates/query_create_intermediate.cpp
+4 -4
View File
@@ -8,12 +8,12 @@ query_create_intermediate::query_create_intermediate() {
context_->parts.push_back(std::make_unique<internal::query_create_part>());
}
executable_query query_create_intermediate::table(const sql::table &table, const std::initializer_list<object::attribute_definition> columns) {
return this->table(table, std::vector<object::attribute_definition>{columns});
executable_query query_create_intermediate::table(const class table &tab, const std::initializer_list<object::attribute_definition> columns) {
return this->table(tab, std::vector<object::attribute_definition>{columns});
}
executable_query query_create_intermediate::table(const sql::table &table, const std::vector<object::attribute_definition> &columns) {
context_->parts.push_back(std::make_unique<internal::query_create_table_part>(table, columns));
executable_query query_create_intermediate::table(const class table &tab, const std::vector<object::attribute_definition> &columns) {
context_->parts.push_back(std::make_unique<internal::query_create_table_part>(tab, columns));
return {context_};
}
source/orm/query/intermediates/query_delete_intermediate.cpp
+3 -5
View File
@@ -6,14 +6,12 @@
namespace matador::query {
query_delete_intermediate::query_delete_intermediate()
{
query_delete_intermediate::query_delete_intermediate() {
context_->parts.push_back(std::make_unique<internal::query_delete_part>());
}
query_delete_from_intermediate query_delete_intermediate::from(const sql::table &table)
{
context_->parts.push_back(std::make_unique<internal::query_delete_from_part>(table));
query_delete_from_intermediate query_delete_intermediate::from(const table &tab) {
context_->parts.push_back(std::make_unique<internal::query_delete_from_part>(tab));
return {context_};
}
source/orm/query/intermediates/query_drop_intermediate.cpp
+2 -2
View File
@@ -8,8 +8,8 @@ query_drop_intermediate::query_drop_intermediate() {
context_->parts.push_back(std::make_unique<internal::query_drop_part>());
}
executable_query query_drop_intermediate::table(const sql::table &table) {
context_->parts.push_back(std::make_unique<internal::query_drop_table_part>(table));
executable_query query_drop_intermediate::table(const class table &tab) {
context_->parts.push_back(std::make_unique<internal::query_drop_table_part>(tab));
return {context_};
}
source/orm/query/intermediates/query_execute_where_intermediate.cpp
+2 -4
View File
@@ -7,14 +7,12 @@
namespace matador::query {
query_execute_limit_intermediate query_execute_where_intermediate::limit(size_t limit)
{
query_execute_limit_intermediate query_execute_where_intermediate::limit(size_t limit) {
context_->parts.push_back(std::make_unique<internal::query_limit_part>(limit));
return {context_};
}
query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const sql::column &col)
{
query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const column &col) {
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_};
}
source/orm/query/intermediates/query_from_intermediate.cpp
+3 -3
View File
@@ -8,7 +8,7 @@
namespace matador::query {
query_join_intermediate query_from_intermediate::join_left(const sql::table &t) {
query_join_intermediate query_from_intermediate::join_left(const table &t) {
context_->parts.push_back(std::make_unique<internal::query_join_part>(t));
return {context_};
}
@@ -38,12 +38,12 @@ query_where_intermediate query_from_intermediate::where_clause(std::unique_ptr<a
return {context_};
}
query_group_by_intermediate query_from_intermediate::group_by(const sql::column &col) {
query_group_by_intermediate query_from_intermediate::group_by(const column &col) {
context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
return {context_};
}
query_order_by_intermediate query_from_intermediate::order_by(const sql::column &col) {
query_order_by_intermediate query_from_intermediate::order_by(const column &col) {
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_};
}
source/orm/query/intermediates/query_group_by_intermediate.cpp
+1 -2
View File
@@ -5,8 +5,7 @@
namespace matador::query {
query_order_by_intermediate query_group_by_intermediate::order_by(const sql::column &col)
{
query_order_by_intermediate query_group_by_intermediate::order_by(const column &col) {
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_};
}
source/orm/query/intermediates/query_insert_intermediate.cpp
+10 -13
View File
@@ -6,33 +6,30 @@
namespace matador::query {
query_insert_intermediate::query_insert_intermediate()
{
query_insert_intermediate::query_insert_intermediate() {
context_->parts.push_back(std::make_unique<internal::query_insert_part>());
}
query_into_intermediate query_insert_intermediate::into(const sql::table &table, const std::initializer_list<sql::column> columns)
{
return into(table, std::move(std::vector<sql::column>{columns}));
query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list<column> columns) {
return into(tab, std::move(std::vector<column>{columns}));
}
query_into_intermediate query_insert_intermediate::into(const sql::table &table, std::vector<sql::column> &&columns)
{
context_->parts.push_back(std::make_unique<internal::query_into_part>(table, columns));
query_into_intermediate query_insert_intermediate::into(const table &tab, std::vector<column> &&columns) {
context_->parts.push_back(std::make_unique<internal::query_into_part>(tab, columns));
return {context_};
}
query_into_intermediate query_insert_intermediate::into(const sql::table &table, const std::vector<std::string> &column_names) {
std::vector<sql::column> columns;
query_into_intermediate query_insert_intermediate::into(const table &tab, const std::vector<std::string> &column_names) {
std::vector<column> columns;
columns.reserve(column_names.size());
for (const auto &col_name : column_names) {
columns.emplace_back(col_name);
}
return into(table, std::move(columns));
return into(tab, std::move(columns));
}
query_into_intermediate query_insert_intermediate::into(const sql::table &table) {
context_->parts.push_back(std::make_unique<internal::query_into_part>(table, table.columns()));
query_into_intermediate query_insert_intermediate::into(const table &tab) {
context_->parts.push_back(std::make_unique<internal::query_into_part>(tab, tab.columns()));
return {context_};
}
source/orm/query/intermediates/query_select_intermediate.cpp
+2 -4
View File
@@ -6,13 +6,11 @@
namespace matador::query {
query_select_intermediate::query_select_intermediate(const std::vector<sql::column>& columns)
{
query_select_intermediate::query_select_intermediate(const std::vector<column>& columns) {
context_->parts.push_back(std::make_unique<internal::query_select_part>(columns));
}
query_from_intermediate query_select_intermediate::from(const sql::table& t)
{
query_from_intermediate query_select_intermediate::from(const table& t) {
context_->parts.push_back(std::make_unique<internal::query_from_part>(t));
context_->tables.insert({t.name(), t});
return {context_};
source/orm/query/intermediates/query_update_intermediate.cpp
+4 -7
View File
@@ -4,18 +4,15 @@
namespace matador::query {
query_update_intermediate::query_update_intermediate(const sql::table& table)
{
context_->parts.push_back(std::make_unique<internal::query_update_part>(table));
query_update_intermediate::query_update_intermediate(const table& tab) {
context_->parts.push_back(std::make_unique<internal::query_update_part>(tab));
}
query_set_intermediate query_update_intermediate::set(const std::initializer_list<internal::column_value_pair> columns)
{
query_set_intermediate query_update_intermediate::set(const std::initializer_list<internal::column_value_pair> columns) {
return set(std::vector<internal::column_value_pair>{columns});
}
query_set_intermediate query_update_intermediate::set(std::vector<internal::column_value_pair> &&columns)
{
query_set_intermediate query_update_intermediate::set(std::vector<internal::column_value_pair> &&columns) {
context_->parts.push_back(std::make_unique<internal::query_set_part>(std::move(columns)));
return {context_};
}
source/orm/query/intermediates/query_where_intermediate.cpp
+2 -4
View File
@@ -6,14 +6,12 @@
namespace matador::query {
query_group_by_intermediate query_where_intermediate::group_by(const sql::column &col)
{
query_group_by_intermediate query_where_intermediate::group_by(const column &col) {
context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
return {context_};
}
query_order_by_intermediate query_where_intermediate::order_by(const sql::column &col)
{
query_order_by_intermediate query_where_intermediate::order_by(const column &col) {
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_};
}
source/orm/query/internal/column_value_pair.cpp
+2 -2
View File
@@ -9,7 +9,7 @@ column_value_pair::column_value_pair(std::string name, utils::database_type valu
, value_(std::move(value)) {
}
column_value_pair::column_value_pair(const sql::column &col, utils::database_type value)
column_value_pair::column_value_pair(const column &col, utils::database_type value)
: column_(col)
, value_(std::move(value)) {
}
@@ -23,7 +23,7 @@ column_value_pair::column_value_pair( const char* name, utils::placeholder p )
: column_(name)
, value_(p) {}
const sql::column &column_value_pair::col() const {
const column &column_value_pair::col() const {
return column_;
}
source/orm/query/internal/query_parts.cpp
+37 -37
View File
@@ -10,21 +10,21 @@ void query_alter_part::accept( query_part_visitor& visitor ) {
visitor.visit(*this);
}
query_alter_table_part::query_alter_table_part(sql::table table )
query_alter_table_part::query_alter_table_part(class table tab)
: query_part(sql::dialect_token::Table)
, table_(std::move(table)) {}
, table_(std::move(tab)) {}
void query_alter_table_part::accept( query_part_visitor& visitor ) {
void query_alter_table_part::accept(query_part_visitor& visitor) {
visitor.visit(*this);
}
const sql::table& query_alter_table_part::table() const {
const table& query_alter_table_part::table() const {
return table_;
}
query_add_key_constraint_part::query_add_key_constraint_part(const std::string& name)
query_add_key_constraint_part::query_add_key_constraint_part(std::string name)
: query_part(sql::dialect_token::AddConstraint)
, name_(name){}
, name_(std::move(name)){}
void query_add_key_constraint_part::accept( query_part_visitor& visitor ) {
visitor.visit(*this);
@@ -34,9 +34,9 @@ const std::string& query_add_key_constraint_part::name() const {
return name_;
}
query_drop_key_constraint_part::query_drop_key_constraint_part( const std::string& name )
query_drop_key_constraint_part::query_drop_key_constraint_part(std::string name)
: query_part( sql::dialect_token::DropConstraint )
, name_( name ){}
, name_(std::move( name )){}
void query_drop_key_constraint_part::accept( query_part_visitor& visitor ) {
visitor.visit(*this);
@@ -53,7 +53,7 @@ void query_drop_foreign_key_constraint_part::accept( query_part_visitor& visitor
visitor.visit(*this);
}
query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<sql::column>& columns)
query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<column>& columns)
: query_part(sql::dialect_token::ForeignKey)
, columns_(columns) {}
@@ -61,28 +61,28 @@ void query_add_foreign_key_constraint_part::accept( query_part_visitor& visitor
visitor.visit(*this);
}
const std::vector<sql::column>& query_add_foreign_key_constraint_part::columns() const {
const std::vector<column>& query_add_foreign_key_constraint_part::columns() const {
return columns_;
}
query_add_foreign_key_reference_part::query_add_foreign_key_reference_part( sql::table table, const std::vector<sql::column>& columns )
query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<column>& columns)
: query_part(sql::dialect_token::References)
, table_(std::move(table))
, table_(std::move(tab))
, columns_(columns) {}
void query_add_foreign_key_reference_part::accept( query_part_visitor& visitor ) {
visitor.visit(*this);
}
const sql::table& query_add_foreign_key_reference_part::table() const {
const table& query_add_foreign_key_reference_part::table() const {
return table_;
}
const std::vector<sql::column>& query_add_foreign_key_reference_part::columns() const {
const std::vector<column>& query_add_foreign_key_reference_part::columns() const {
return columns_;
}
query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<sql::column>& columns)
query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<column>& columns)
: query_part(sql::dialect_token::PrimaryKey)
, columns_(columns) {}
@@ -90,11 +90,11 @@ void query_add_primary_key_constraint_part::accept( query_part_visitor& visitor
visitor.visit(*this);
}
const std::vector<sql::column>& query_add_primary_key_constraint_part::columns() const {
const std::vector<column>& query_add_primary_key_constraint_part::columns() const {
return columns_;
}
query_select_part::query_select_part(std::vector<sql::column> columns)
query_select_part::query_select_part(std::vector<column> columns)
: query_part(sql::dialect_token::Select)
, columns_(std::move(columns)) {}
@@ -103,16 +103,16 @@ void query_select_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
const std::vector<sql::column>& query_select_part::columns() const
const std::vector<column>& query_select_part::columns() const
{
return columns_;
}
query_from_part::query_from_part(sql::table t)
query_from_part::query_from_part(class table t)
: query_part(sql::dialect_token::From)
, table_(std::move(t)) {}
const sql::table &query_from_part::table() const
const table &query_from_part::table() const
{
return table_;
}
@@ -122,11 +122,11 @@ void query_from_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
query_join_part::query_join_part(sql::table t)
query_join_part::query_join_part(class table t)
: query_part(sql::dialect_token::Join)
, table_(std::move(t)) {}
const sql::table &query_join_part::table() const
const table &query_join_part::table() const
{
return table_;
}
@@ -168,12 +168,12 @@ query_table_name_part::query_table_name_part(const sql::dialect_token token, std
: query_part(token)
, table_name_(std::move(table_name)) {}
query_group_by_part::query_group_by_part(sql::column col)
query_group_by_part::query_group_by_part(class column col)
: query_part(sql::dialect_token::GroupBy)
, column_(std::move(col))
{}
const sql::column &query_group_by_part::column() const
const column &query_group_by_part::column() const
{
return column_;
}
@@ -183,12 +183,12 @@ void query_group_by_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
query_order_by_part::query_order_by_part(sql::column col)
query_order_by_part::query_order_by_part(class column col)
: query_part(sql::dialect_token::OrderBy)
, column_(std::move(col))
{}
const sql::column &query_order_by_part::column() const
const column &query_order_by_part::column() const
{
return column_;
}
@@ -252,17 +252,17 @@ void query_insert_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
query_into_part::query_into_part(sql::table t, std::vector<sql::column> columns)
query_into_part::query_into_part(class table t, std::vector<column> columns)
: query_part(sql::dialect_token::Insert)
, table_(std::move(t))
, columns_(std::move(columns)) {}
const sql::table &query_into_part::table() const
const table &query_into_part::table() const
{
return table_;
}
const std::vector<sql::column> &query_into_part::columns() const
const std::vector<column> &query_into_part::columns() const
{
return columns_;
}
@@ -286,11 +286,11 @@ void query_values_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
query_update_part::query_update_part(sql::table table)
query_update_part::query_update_part(class table table)
: query_part(sql::dialect_token::Update)
, table_(std::move(table)) {}
const sql::table& query_update_part::table() const
const table& query_update_part::table() const
{
return table_;
}
@@ -322,11 +322,11 @@ void query_delete_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
query_delete_from_part::query_delete_from_part(sql::table table)
query_delete_from_part::query_delete_from_part(class table table)
: query_part(sql::dialect_token::From)
, table_(std::move(table)) {}
const sql::table &query_delete_from_part::table() const
const table &query_delete_from_part::table() const
{
return table_;
}
@@ -344,12 +344,12 @@ void query_create_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
query_create_table_part::query_create_table_part(sql::table table, std::vector<object::attribute_definition> columns)
query_create_table_part::query_create_table_part(class table table, std::vector<object::attribute_definition> columns)
: query_part(sql::dialect_token::Table)
, table_(std::move(table))
, columns_(std::move(columns)) {}
const sql::table &query_create_table_part::table() const
const table &query_create_table_part::table() const
{
return table_;
}
@@ -384,11 +384,11 @@ void query_drop_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
query_drop_table_part::query_drop_table_part(sql::table table)
query_drop_table_part::query_drop_table_part(class table table)
: query_part(sql::dialect_token::Table)
, table_(std::move(table)) {}
const sql::table &query_drop_table_part::table() const
const table &query_drop_table_part::table() const
{
return table_;
}
source/orm/query/query.cpp
+11 -15
View File
@@ -2,24 +2,20 @@
namespace matador::query {
sql::column alias(const std::string &column, const std::string &as)
{
return sql::column{column, as};
column alias(const std::string &column, const std::string &as) {
return {column, as};
}
sql::column alias(sql::column &&col, const std::string &as)
{
column alias(column &&col, const std::string &as) {
col.as(as);
return std::move(col);
}
sql::column count(const std::string &column)
{
column count(const std::string &column) {
return {sql::sql_function_t::Count, column};
}
sql::column count_all()
{
column count_all() {
return count("*");
}
@@ -36,16 +32,16 @@ query_select_intermediate query::select() {
return query_select_intermediate{{}};
}
query_select_intermediate query::select( const std::initializer_list<sql::column> columns) {
return select(std::vector<sql::column>{columns});
query_select_intermediate query::select( const std::initializer_list<column> columns) {
return select(std::vector<column>{columns});
}
query_select_intermediate query::select(const std::vector<sql::column>& columns) {
query_select_intermediate query::select(const std::vector<column>& columns) {
return query_select_intermediate{columns};
}
query_select_intermediate query::select(const std::vector<std::string> &column_names) {
std::vector<sql::column> columns;
std::vector<column> columns;
columns.reserve(column_names.size());
for (const auto &col_name : column_names) {
columns.emplace_back(col_name);
@@ -53,7 +49,7 @@ query_select_intermediate query::select(const std::vector<std::string> &column_n
return select(columns);
}
query_select_intermediate query::select(std::vector<sql::column> columns, const std::initializer_list<sql::column> additional_columns) {
query_select_intermediate query::select(std::vector<column> columns, const std::initializer_list<column> additional_columns) {
for (const auto &col : additional_columns) {
columns.push_back(col);
}
@@ -64,7 +60,7 @@ query_insert_intermediate query::insert() {
return {};
}
query_update_intermediate query::update(const sql::table &table) {
query_update_intermediate query::update(const table &table) {
return query_update_intermediate{table};
}
source/orm/query/query_compiler.cpp
+24 -22
View File
@@ -1,8 +1,11 @@
#include "matador/query/query_compiler.hpp"
#include "matador/object/object_definition.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"
@@ -33,7 +36,7 @@ sql::query_context query_compiler::compile(const query_data &data,
return {query_};
}
std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const sql::column &col) {
std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const column &col) {
ctx.result_vars.emplace_back(col.column_name());
const auto& column_table = col.table().get();
ctx.column_aliases.insert({column_table->has_alias() ? column_table->alias() : column_table->name() + "." + col.column_name(), col.alias()});
@@ -45,10 +48,10 @@ std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const
}
if (const auto it = data.tables.find(col.table()->name()); it != data.tables.end()) {
return d->prepare_identifier({it->second, col.column_name(), col.alias()});
return prepare_identifier(*d, {it->second, col.column_name(), col.alias()});
}
return d->prepare_identifier(col);
return prepare_identifier(*d, col);
}
void query_compiler::visit(internal::query_alter_part& part) {
@@ -134,11 +137,10 @@ void query_compiler::visit(internal::query_select_part &part)
query_.sql += result;
}
void query_compiler::visit(internal::query_from_part &part)
{
query_.table = part.table();
query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table);
query_.table_aliases.insert({query_.table.name(), query_.table.alias()});
void query_compiler::visit(internal::query_from_part &part) {
query_.table_name = part.table().alias();
query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
query_.table_aliases.insert({query_.table_name, part.table().alias()});
}
void query_compiler::visit(internal::query_join_part &part)
@@ -159,13 +161,13 @@ void query_compiler::visit(internal::query_where_part &part) {
}
void query_compiler::visit(internal::query_group_by_part &part) {
query_.sql += " " + dialect_->token_at(sql::dialect_token::GroupBy) + " " + dialect_->prepare_identifier(part.column());
query_.sql += " " + dialect_->token_at(sql::dialect_token::GroupBy) + " " + prepare_identifier(*dialect_, part.column());
}
void query_compiler::visit(internal::query_order_by_part &part)
{
query_.sql += " " + dialect_->token_at(sql::dialect_token::OrderBy) +
" " + dialect_->prepare_condition(part.column());
" " + prepare_criteria(*dialect_, part.column());
}
void query_compiler::visit(internal::query_order_by_asc_part &/*order_by_asc_part*/)
@@ -196,7 +198,7 @@ void query_compiler::visit(internal::query_insert_part &/*insert_part*/)
void query_compiler::visit(internal::query_into_part &part)
{
query_.table = part.table();
query_.table_name = part.table().name();
query_.sql += " " + dialect_->token_at(sql::dialect_token::Into) +
" " + dialect_->prepare_identifier_string(part.table().name());
@@ -267,8 +269,8 @@ void query_compiler::visit(internal::query_values_part &part) {
void query_compiler::visit(internal::query_update_part &part)
{
query_.command = sql::sql_command::SQL_UPDATE;
query_.table = part.table();
query_.sql += query_compiler::build_table_name(part.token(), *dialect_, query_.table);
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*/)
@@ -279,8 +281,8 @@ void query_compiler::visit(internal::query_delete_part &/*delete_part*/)
void query_compiler::visit(internal::query_delete_from_part &part)
{
query_.table = part.table();
query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table);
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*/)
@@ -305,7 +307,7 @@ std::string build_create_column(const object::attribute_definition &col, const s
void query_compiler::visit(internal::query_create_table_part &part)
{
query_.sql += " " + dialect_->token_at(sql::dialect_token::Table) + " " + dialect_->prepare_identifier_string(part.table().name()) + " ";
query_.table = part.table();
query_.table_name = part.table().name();
std::string result = "(";
@@ -329,11 +331,11 @@ void query_compiler::visit(internal::query_create_table_part &part)
}
for (const auto &[column, reference_column]: context.foreign_contexts) {
// ALTER TABLE Orders ADD CONSTRAINT FK_PersonOrder FOREIGN KEY (PersonID) REFERENCES Persons(PersonID);
std::string fk_cmd = "ALTER TABLE " + dialect_->prepare_identifier_string(query_.table.name()) + " ADD";
fk_cmd += " CONSTRAINT FK_" + query_.table.name();
std::string fk_cmd = "ALTER TABLE " + dialect_->prepare_identifier_string(query_.table_name) + " ADD";
fk_cmd += " CONSTRAINT FK_" + query_.table_name;
fk_cmd += "_" + column;
fk_cmd += " FOREIGN KEY (" + dialect_->prepare_identifier_string(column) + ")";
fk_cmd += " REFERENCES " + reference_column->table_name() + "(" + reference_column->name() + ")";
fk_cmd += " REFERENCES " + reference_column->object()->name() + "(" + reference_column->name() + ")";
query_.additional_commands.push_back({fk_cmd, sql::sql_command::SQL_ALTER_TABLE});
}
@@ -383,8 +385,8 @@ void query_compiler::visit(internal::query_set_part &part) {
void query_compiler::visit(internal::query_drop_table_part &part)
{
query_.table = part.table();
query_.sql += " " + query_compiler::build_table_name(part.token(), *dialect_, query_.table);
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_definition &col, const sql::dialect &d, column_context &context)
@@ -409,7 +411,7 @@ std::string build_create_column(const object::attribute_definition &col, const s
return result;
}
std::string query_compiler::build_table_name(const sql::dialect_token token, const sql::dialect &d, const sql::table& t)
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()) + "." : "") +
source/orm/query/query_utils.cpp
+39
View File
@@ -0,0 +1,39 @@
#include "matador/query/query_utils.hpp"
#include "matador/query/table.hpp"
namespace matador::query {
std::string prepare_identifier( const sql::dialect& d, const column& col ) {
std::string result;
if (!col.is_function()) {
if (!col.table()->name().empty()) {
result = d.prepare_identifier_string(col.table()->has_alias() ? col.table()->alias() : col.table()->name()) + ".";
}
result += d.prepare_identifier_string(col.column_name());
} else {
result = d.sql_function_at(col.function()) + "(" + col.column_name() + ")";
}
if (!col.alias().empty()) {
result += " AS " + col.alias();
}
return result;
}
std::string prepare_criteria(const sql::dialect& d, const column& col) {
std::string result;
if (!col.is_function()) {
// if (!col.alias.empty()) {
// result = col.alias;
// } else {
if (!col.table()->name().empty()) {
result = d.prepare_identifier_string(col.table()->has_alias() ? col.table()->alias() : col.table()->name()) + ".";
}
result += d.prepare_identifier_string(col.column_name());
// }
} else {
result = d.sql_function_at(col.function()) + "(" + col.column_name() + ")";
}
return result;
}
}
source/orm/sql/table.cpp → source/orm/query/table.cpp
+2 -2
View File
@@ -1,6 +1,6 @@
#include "matador/sql/table.hpp"
#include "matador/query/table.hpp"
namespace matador::sql {
namespace matador::query {
table::table(const char* name)
: table(std::string(name))
source/orm/sql/connection.cpp
+1 -1
View File
@@ -221,7 +221,7 @@ const class dialect &connection::dialect() const
utils::result<std::unique_ptr<statement_impl>, utils::error> connection::perform_prepare(const query_context& ctx) const {
if (ctx.command != sql_command::SQL_CREATE_TABLE && (ctx.prototype.empty() || has_unknown_columns(ctx.prototype))) {
if (const auto result = describe(ctx.table.name()); result.is_ok()) {
if (const auto result = describe(ctx.table_name); result.is_ok()) {
for (auto &col: ctx.prototype) {
const auto rit = std::find_if(
std::begin(*result),
source/orm/sql/dialect.cpp
+4 -38
View File
@@ -6,31 +6,16 @@
namespace matador::sql {
const std::string& dialect::token_at(const dialect_token token) const
{
const std::string& dialect::token_at(const dialect_token token) const {
return tokens_.at(token);
}
const std::string &dialect::data_type_at(const utils::basic_type type) const
{
const std::string &dialect::data_type_at(const utils::basic_type type) const {
return data_types_.at(type);
}
std::string dialect::prepare_identifier(const sql::column &col) const
{
std::string result;
if (!col.is_function()) {
if (!col.table()->name().empty()) {
result = prepare_identifier_string(col.table()->has_alias() ? col.table()->alias() : col.table()->name()) + ".";
}
result += prepare_identifier_string(col.column_name());
} else {
result = sql_func_map_.at(col.function()) + "(" + col.column_name() + ")";
}
if (!col.alias().empty()) {
result += " AS " + col.alias();
}
return result;
const std::string& dialect::sql_function_at(const sql_function_t func) const {
return sql_func_map_.at(func);
}
std::string dialect::table_name( const std::string& table, const std::string& schema_name ) const {
@@ -43,25 +28,6 @@ std::string dialect::table_name( const std::string& table, const std::string& sc
return prepare_identifier_string( schema_name ) + "." + prepare_identifier_string( table );
}
std::string dialect::prepare_condition(const sql::column& col) const
{
std::string result;
if (!col.is_function()) {
// if (!col.alias.empty()) {
// result = col.alias;
// } else {
if (!col.table()->name().empty()) {
result = prepare_identifier_string(col.table()->has_alias() ? col.table()->alias() : col.table()->name()) + ".";
}
result += prepare_identifier_string(col.column_name());
// }
} else {
result = sql_func_map_.at(col.function()) + "(" + col.column_name() + ")";
}
return result;
}
const std::string& dialect::to_string(const bool val) const
{
return bool_strings_[static_cast<int>(val)];
source/orm/sql/executor.cpp
-4
View File
@@ -1,4 +0,0 @@
#include "matador/sql/executor.hpp"
namespace matador::sql {
}
source/orm/sql/record.cpp
+2 -4
View File
@@ -1,5 +1,4 @@
#include "matador/sql/record.hpp"
#include "matador/sql/column.hpp"
#include <algorithm>
#include <stdexcept>
@@ -67,9 +66,8 @@ const std::vector<record::field_ref> &record::columns() const
// return columns_[pk_index_];
//}
const field &record::at(const sql::column &col) const
{
const auto &res = fields_by_name_.at(col.column_name());
const field &record::at(const std::string &name) const {
const auto &res = fields_by_name_.at(name);
const auto &f = res.first;
return f;
}