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

Compare commits

base: sascha:9c42df3f831062636df6e84c7aae8e66b35876f6
Branches Tags
sascha:main
sascha:feature/matador-ng
..
compare: sascha:7242dc2612353ff75d79c346c0b0c999feea2d50
Branches Tags
sascha:feature/matador-ng
sascha:main

No commits in common. "9c42df3f831062636df6e84c7aae8e66b35876f6" and "7242dc2612353ff75d79c346c0b0c999feea2d50" have entirely different histories.
9c42df3f83 ... 7242dc2612

80 changed files with 496 additions and 715 deletions
Show Stats Expand all files Collapse all files

2
backends/postgres/src/postgres_connection.cpp
View File

@ -110,7 +110,7 @@ utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> postgres_co
std::string postgres_connection::generate_statement_name(const sql::query_context &query) {
std::stringstream name;
name << query.table_name.name() << "_" << query.command_name;
name << query.table.name() << "_" << query.command_name;
auto result = postgres_connection::statement_name_map_.find(name.str());
if (result == postgres_connection::statement_name_map_.end()) {

2
demo/main.cpp
View File

@ -1,4 +1,4 @@
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/query_macro.hpp"

54
include/matador/orm/session_query_builder.hpp
View File

@ -23,9 +23,9 @@
namespace matador::orm {
struct entity_query_data {
std::shared_ptr<query::table> root_table;
std::shared_ptr<sql::table> root_table;
std::string pk_column_name{};
std::vector<query::column> columns{};
std::vector<sql::column> columns{};
std::unordered_map<std::string, sql::statement> lazy_loading_statements{};
std::vector<query::join_data> joins{};
query::criteria_ptr where_clause{};
@ -33,7 +33,7 @@ struct entity_query_data {
class criteria_transformer final : public query::criteria_visitor {
public:
criteria_transformer(const object::repository &repo, const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name);
criteria_transformer(const object::repository &repo, const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name);
void visit( const query::between_criteria& node ) override;
void visit( const query::binary_criteria& node ) override;
void visit( const query::binary_column_criteria& node ) override;
@ -48,7 +48,7 @@ private:
private:
const object::repository &repo_;
const std::unordered_map<std::string, std::shared_ptr<query::table>>& tables_by_name_;
const std::unordered_map<std::string, std::shared_ptr<sql::table>>& tables_by_name_;
};
class session_query_builder final {
@ -63,7 +63,7 @@ public:
if (!info) {
return utils::failure(query_build_error::UnknownType);
}
table_info_stack_.push({info.value(), std::make_shared<query::table>(info.value().get().name(), build_alias('t', ++table_index))});
table_info_stack_.push({info.value(), std::make_shared<sql::table>(info.value().get().name(), build_alias('t', ++table_index))});
entity_query_data_ = { table_info_stack_.top().table };
processed_tables_.insert({info->get().name(), entity_query_data_.root_table});
try {
@ -123,7 +123,7 @@ public:
if (next != processed_tables_.end()) {
return;
}
table_info_stack_.push({info.value(), std::make_shared<query::table>(info->get().name(), build_alias('t', ++table_index))});
table_info_stack_.push({info.value(), std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index))});
next = processed_tables_.insert({info->get().name(), table_info_stack_.top().table}).first;
typename ContainerType::value_type::value_type obj;
access::process(*this , obj);
@ -135,8 +135,8 @@ public:
}
append_join(
query::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
query::column{next->second, join_column}
sql::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
sql::column{next->second, join_column}
);
}
}
@ -157,10 +157,10 @@ public:
}
auto relation = processed_tables_.find(id);
if (relation == processed_tables_.end()) {
relation = processed_tables_.insert({id, std::make_shared<query::table>(id, build_alias('t', ++table_index))}).first;
relation = processed_tables_.insert({id, std::make_shared<sql::table>(id, build_alias('t', ++table_index))}).first;
}
table_info_stack_.push({info.value(), std::make_shared<query::table>(info->get().name(), build_alias('t', ++table_index))});
table_info_stack_.push({info.value(), std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index))});
next = processed_tables_.insert({info->get().name(), table_info_stack_.top().table}).first;
typename ContainerType::value_type::value_type obj;
access::process(*this , obj);
@ -172,12 +172,12 @@ public:
}
append_join(
query::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
query::column{relation->second, join_column}
sql::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
sql::column{relation->second, join_column}
);
append_join(
query::column{relation->second, inverse_join_column},
query::column{next->second, pk->name()}
sql::column{relation->second, inverse_join_column},
sql::column{next->second, pk->name()}
);
}
@ -198,9 +198,9 @@ public:
auto relation = processed_tables_.find(id);
if (relation == processed_tables_.end()) {
relation = processed_tables_.insert({id, std::make_shared<query::table>(id, build_alias('t', ++table_index))}).first;
relation = processed_tables_.insert({id, std::make_shared<sql::table>(id, build_alias('t', ++table_index))}).first;
}
table_info_stack_.push({info.value(), std::make_shared<query::table>(info->get().name(), build_alias('t', ++table_index))});
table_info_stack_.push({info.value(), std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index))});
next = processed_tables_.insert({info->get().name(), table_info_stack_.top().table}).first;
typename ContainerType::value_type::value_type obj;
access::process(*this , obj);
@ -214,12 +214,12 @@ public:
const auto join_columns = join_columns_collector_.collect<typename ContainerType::value_type::value_type>();
append_join(
query::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
query::column{relation->second, join_columns.inverse_join_column}
sql::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
sql::column{relation->second, join_columns.inverse_join_column}
);
append_join(
query::column{relation->second, join_columns.join_column},
query::column{next->second, pk->name()}
sql::column{relation->second, join_columns.join_column},
sql::column{next->second, pk->name()}
);
}
@ -229,16 +229,16 @@ private:
void push(const std::string &column_name);
static std::string build_alias(char prefix, unsigned int count);
[[nodiscard]] bool is_root_entity() const;
void append_join(const query::column &left, const query::column &right);
void append_join(const sql::column &left, const sql::column &right);
private:
struct table_info {
std::reference_wrapper<const object::basic_object_info> info;
std::shared_ptr<query::table> table;
std::shared_ptr<sql::table> table;
};
std::stack<table_info> table_info_stack_{};
std::unordered_map<std::string, std::shared_ptr<query::table>> processed_tables_{};
std::unordered_map<std::string, std::shared_ptr<sql::table>> processed_tables_{};
const object::repository &schema_;
entity_query_data entity_query_data_{};
unsigned int column_index{0};
@ -258,7 +258,7 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u
throw query_builder_exception{query_build_error::MissingPrimaryKey};
}
const auto foreign_table = std::make_shared<query::table>(info->get().name(), build_alias('t', ++table_index));
const auto foreign_table = std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index));
if (attr.fetch() == utils::fetch_type::EAGER) {
auto next = processed_tables_.find(info->get().name());
@ -272,8 +272,8 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u
table_info_stack_.pop();
append_join(
query::column{table_info_stack_.top().table, id},
query::column{next->second, pk->name()}
sql::column{table_info_stack_.top().table, id},
sql::column{next->second, pk->name()}
);
} else {
push(id);
@ -282,7 +282,7 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u
// create select query
auto result = matador::query::query::select(generator::columns<typename Pointer::value_type>(schema_, generator::column_generator_options::ForceLazy))
.from(*foreign_table)
.where(column(foreign_table, pk->name(), "") == _)
.where(sql::column(foreign_table, pk->name(), "") == _)
.prepare(executor_);
if (!result) {
throw query_builder_exception(query_build_error::QueryError, result.release_error());

63
include/matador/query/builder.hpp
View File

@ -1,63 +0,0 @@
#ifndef MATADOR_BUILDER_HPP
#define MATADOR_BUILDER_HPP
#include "matador/query/column.hpp"
#include "matador/query/table.hpp"
#include <string>
namespace matador::query {
class column_builder {
public:
explicit column_builder(std::string column_name);
// ReSharper disable once CppNonExplicitConversionOperator
operator query::column() const; // NOLINT(*-explicit-constructor)
private:
std::string column_name;
};
struct constraint {
std::string name;
};
class table_builder {
public:
explicit table_builder(std::string name);
table_builder& as(std::string table_alias);
// ReSharper disable once CppNonExplicitConversionOperator
operator query::table() const; // NOLINT(*-explicit-constructor)
private:
std::string table_name;
std::string alias;
};
class constraint_builder {
public:
constraint_builder& constraint(std::string name);
constraint_builder& primary_key(std::string name);
constraint_builder& foreign_key(std::string name);
constraint_builder& references(std::string table, std::string column);
// ReSharper disable once CppNonExplicitConversionOperator
operator query::constraint() const; // NOLINT(*-explicit-constructor)
private:
std::string constraint_name;
std::string pk_column_name;
std::string fk_column_name;
std::string table_name;
std::string column_name;
};
constraint_builder constraint(std::string name);
table_builder table(std::string name);
column_builder column(std::string name);
}
#endif //MATADOR_BUILDER_HPP

8
include/matador/query/criteria/abstract_column_criteria.hpp
View File

@ -3,19 +3,19 @@
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
namespace matador::query {
class abstract_column_criteria : public abstract_criteria {
public:
abstract_column_criteria() = delete;
explicit abstract_column_criteria(column col);
explicit abstract_column_criteria(sql::column column);
[[nodiscard]] const column& col() const;
[[nodiscard]] const sql::column& column() const;
protected:
column column_;
sql::column column_;
};
}

4
include/matador/query/criteria/between_criteria.hpp
View File

@ -11,8 +11,8 @@ namespace matador::query {
class between_criteria final : public abstract_column_criteria {
public:
between_criteria() = delete;
between_criteria(column col, int64_t min, int64_t max);
between_criteria(column col, utils::placeholder min, utils::placeholder max);
between_criteria(sql::column column, int64_t min, int64_t max);
between_criteria(sql::column column, utils::placeholder min, utils::placeholder max);
void accept(criteria_visitor& visitor) const override;

14
include/matador/query/criteria/binary_criteria.hpp
View File

@ -4,7 +4,7 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/query/criteria/criteria_utils.hpp"
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
namespace matador::query {
enum class binary_operator {
@ -19,7 +19,7 @@ enum class binary_operator {
class binary_criteria final : public abstract_column_criteria {
public:
binary_criteria() = delete;
binary_criteria(column col, binary_operator operand, criteria_value value);
binary_criteria(sql::column column, binary_operator operand, criteria_value value);
void accept( criteria_visitor& visitor ) const override;
@ -34,18 +34,18 @@ private:
class binary_column_criteria final : public abstract_criteria {
public:
binary_column_criteria() = delete;
binary_column_criteria(column left_column, binary_operator operand, column right_column);
binary_column_criteria(sql::column left_column, binary_operator operand, sql::column right_column);
void accept(criteria_visitor& visitor) const override;
[[nodiscard]] const column& left_column() const;
[[nodiscard]] const sql::column& left_column() const;
[[nodiscard]] binary_operator operand() const;
[[nodiscard]] const column& right_column() const;
[[nodiscard]] const sql::column& right_column() const;
private:
column left_column_;
sql::column left_column_;
binary_operator operator_{};
column right_column_;
sql::column right_column_;
};
}
#endif //CRITERIA_BINARY_CRITERIA_NODE_HPP

8
include/matador/query/criteria/collection_criteria.hpp
View File

@ -4,7 +4,7 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/query/criteria/criteria_utils.hpp"
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
#include "matador/sql/query_context.hpp"
namespace matador::query {
@ -36,8 +36,8 @@ public:
* @param operand_ Operator to use
* @param values List of values
*/
collection_criteria(column col, collection_operator operand_, std::vector<criteria_value> values);
collection_criteria(column col, collection_operator operand_, std::initializer_list<criteria_value> values);
collection_criteria(sql::column col, collection_operator operand_, std::vector<criteria_value> values);
collection_criteria(sql::column col, collection_operator operand_, std::initializer_list<criteria_value> values);
void accept(criteria_visitor& visitor) const override;
@ -52,7 +52,7 @@ private:
class collection_query_criteria final : public abstract_column_criteria {
public:
collection_query_criteria() = delete;
collection_query_criteria(column col, collection_operator operand_, sql::query_context ctx);
collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx);
void accept(criteria_visitor& visitor) const override;

56
include/matador/query/criteria/criteria_operators.hpp
View File

@ -4,7 +4,7 @@
#include "matador/query/criteria/binary_criteria.hpp"
#include "matador/query/criteria/collection_criteria.hpp"
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
#include "matador/utils/placeholder.hpp"
#include "matador/utils/value.hpp"
@ -15,48 +15,48 @@ struct query_context;
namespace matador::query {
template<class Type>
criteria_ptr operator==(const column &col, Type val) {
criteria_ptr operator==(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, utils::value(val));
}
template<class Type>
criteria_ptr operator!=(const column &col, Type val) {
criteria_ptr operator!=(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, utils::value(val));
}
template<class Type>
criteria_ptr operator>(const column &col, Type val) {
criteria_ptr operator>(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, utils::value(val));
}
template<class Type>
criteria_ptr operator>=(const column &col, Type val) {
criteria_ptr operator>=(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, utils::value(val));
}
template<class Type>
criteria_ptr operator<(const column &col, Type val) {
criteria_ptr operator<(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, utils::value(val));
}
template<class Type>
criteria_ptr operator<=(const column &col, Type val) {
criteria_ptr operator<=(const sql::column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, utils::value(val));
}
criteria_ptr operator==(const column &col_left, const column &col_right);
criteria_ptr operator!=(const column &col_left, const column &col_right);
criteria_ptr operator>(const column &col_left, const column &col_right);
criteria_ptr operator>=(const column &col_left, const column &col_right);
criteria_ptr operator<(const column &col_left, const column &col_right);
criteria_ptr operator<=(const column &col_left, const column &col_right);
criteria_ptr operator==(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator!=(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator>(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator>=(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator<(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator<=(const sql::column &col_left, const sql::column &col_right);
criteria_ptr operator==(const column &col, utils::placeholder p);
criteria_ptr operator!=(const column &col, utils::placeholder p);
criteria_ptr operator>(const column &col, utils::placeholder p);
criteria_ptr operator>=(const column &col, utils::placeholder p);
criteria_ptr operator<(const column &col, utils::placeholder p);
criteria_ptr operator<=(const column &col, utils::placeholder p);
criteria_ptr operator==(const sql::column &col, utils::placeholder p);
criteria_ptr operator!=(const sql::column &col, utils::placeholder p);
criteria_ptr operator>(const sql::column &col, utils::placeholder p);
criteria_ptr operator>=(const sql::column &col, utils::placeholder p);
criteria_ptr operator<(const sql::column &col, utils::placeholder p);
criteria_ptr operator<=(const sql::column &col, utils::placeholder p);
criteria_ptr operator&&(criteria_ptr left, criteria_ptr right);
@ -65,7 +65,7 @@ criteria_ptr operator||(criteria_ptr left, criteria_ptr right);
criteria_ptr operator!(criteria_ptr clause);
template < class Type >
criteria_ptr in(const column &col, std::initializer_list<Type> args) {
criteria_ptr in(const sql::column &col, std::initializer_list<Type> args) {
std::vector<criteria_value> values;
for ( auto &&arg : args ) {
values.emplace_back(utils::value{std::move(arg)});
@ -74,12 +74,12 @@ criteria_ptr in(const column &col, std::initializer_list<Type> args) {
}
template <>
criteria_ptr in(const column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr in(const sql::column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr in(const column &col, sql::query_context &&ctx);
criteria_ptr in(const sql::column &col, sql::query_context &&ctx);
template < class Type >
criteria_ptr out(const column &col, std::initializer_list<Type> args) {
criteria_ptr out(const sql::column &col, std::initializer_list<Type> args) {
std::vector<criteria_value> values;
for ( auto &&arg : args ) {
values.emplace_back(utils::value{std::move(arg)});
@ -88,14 +88,14 @@ criteria_ptr out(const column &col, std::initializer_list<Type> args) {
}
template <>
criteria_ptr out(const column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr out(const sql::column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr out(const column &col, sql::query_context &&ctx);
criteria_ptr out(const sql::column &col, sql::query_context &&ctx);
criteria_ptr between(const column &col, int64_t min, int64_t max);
criteria_ptr between(const column &col, utils::placeholder min, utils::placeholder max);
criteria_ptr between(const sql::column &col, int64_t min, int64_t max);
criteria_ptr between(const sql::column &col, utils::placeholder min, utils::placeholder max);
criteria_ptr like(const column &col, const std::string &pattern);
criteria_ptr like(const sql::column &col, const std::string &pattern);
}
#endif //CRITERIA_CRITERIA_OPERATORS_HPP

4
include/matador/query/criteria/like_criteria.hpp
View File

@ -3,13 +3,13 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
namespace matador::query {
class like_criteria final : public abstract_column_criteria {
public:
like_criteria() = delete;
like_criteria(column col, std::string pattern);
like_criteria(sql::column column, std::string pattern);
void accept(criteria_visitor &visitor) const override;

42
include/matador/query/generator.hpp
View File

@ -11,7 +11,7 @@
#include "matador/query/fk_value_extractor.hpp"
#include "matador/query/internal/column_value_pair.hpp"
#include "matador/query/table.hpp"
#include "matador/sql/table.hpp"
#include <vector>
@ -53,13 +53,13 @@ public:
column_generator_options options = default_column_generator_options);
template< class Type >
std::vector<column> generate() {
std::vector<sql::column> generate() {
Type obj;
return generate(obj);
}
template< class Type >
std::vector<column> generate(const Type &obj) {
std::vector<sql::column> generate(const Type &obj) {
result_.clear();
access::process(*this, obj);
@ -101,7 +101,7 @@ public:
if (seen_tables.count(info->get().name()) == 0) {
auto it = seen_tables.insert(info->get().name()).first;
table_stack_.push(std::make_shared<table>(info.value().get().name()));
table_stack_.push(std::make_shared<sql::table>(info.value().get().name()));
typename ContainerType::value_type::value_type obj;
access::process(*this, obj);
table_stack_.pop();
@ -136,7 +136,7 @@ private:
}
if (seen_tables.count(info->get().name()) == 0) {
auto it = seen_tables.insert(info->get().name()).first;
table_stack_.push(std::make_shared<table>(info.value().get().name()));
table_stack_.push(std::make_shared<sql::table>(info.value().get().name()));
typename Pointer::value_type obj;
access::process(*this, obj);
table_stack_.pop();
@ -149,8 +149,8 @@ private:
private:
std::optional<std::reference_wrapper<const object::repository>> repo_;
std::vector<column> result_;
std::stack<std::shared_ptr<table>> table_stack_;
std::vector<sql::column> result_;
std::stack<std::shared_ptr<sql::table>> table_stack_;
std::unordered_set<std::string> seen_tables;
int column_index{0};
column_generator_options options_{false};
@ -296,16 +296,16 @@ std::vector<internal::column_value_pair> column_value_pairs() {
}
template<typename Type>
std::vector<column> columns(const object::repository &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
std::vector<sql::column> columns(const object::repository &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
column_generator generator(repo, table_name, options);
return generator.generate<Type>();
}
template<typename Type>
std::vector<column> columns(const object::repository &repo,
const column_generator_options options) {
std::vector<sql::column> columns(const object::repository &repo,
const column_generator_options options) {
std::string table_name;
if (const auto result = repo.info<Type>()) {
table_name = result.value().get().name();
@ -315,25 +315,25 @@ std::vector<column> columns(const object::repository &repo,
}
template<typename Type>
std::vector<column> columns(const Type &obj,
const object::repository &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
std::vector<sql::column> columns(const Type &obj,
const object::repository &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
column_generator generator(repo, table_name, options);
return generator.generate(obj);
}
template<typename Type>
std::vector<column> columns(const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
std::vector<sql::column> columns(const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
column_generator generator(table_name, options);
return generator.generate<Type>();
}
template<typename Type>
std::vector<column> columns(const Type &obj,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
std::vector<sql::column> columns(const Type &obj,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
column_generator generator(table_name, options);
return generator.generate(obj);
}

2
include/matador/query/intermediates/query_alter_intermediate.hpp
View File

@ -9,7 +9,7 @@ class query_alter_intermediate : public query_intermediate {
public:
query_alter_intermediate();
query_alter_table_intermediate table(const table &tab) const;
query_alter_table_intermediate table(const sql::table &table) const;
};
}

14
include/matador/query/intermediates/query_alter_table_intermediate.hpp
View File

@ -13,21 +13,21 @@ class query_add_foreign_key_constraint_intermediate final : public query_interme
public:
using query_intermediate::query_intermediate;
executable_query references(const table& tab, const std::vector<column>& columns = {});
executable_query references(const sql::table& table, const std::vector<sql::column>& columns = {});
private:
table table_;
std::vector<column> columns_;
sql::table table_;
std::vector<sql::column> columns_;
};
class query_add_key_constraint_intermediate final : public query_intermediate {
public:
using query_intermediate::query_intermediate;
[[nodiscard]] query_add_primary_key_constraint_intermediate primary_key(const column& col) const;
[[nodiscard]] query_add_primary_key_constraint_intermediate primary_keys(const std::vector<column>& columns) const;
[[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_key(const column& col) const;
[[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_keys(const std::vector<column>& columns) const;
query_add_primary_key_constraint_intermediate primary_key(const sql::column& column) const;
query_add_primary_key_constraint_intermediate primary_keys(const std::vector<sql::column>& columns) const;
query_add_foreign_key_constraint_intermediate foreign_key(const sql::column& column) const;
query_add_foreign_key_constraint_intermediate foreign_keys(const std::vector<sql::column>& columns) const;
};
class query_alter_table_intermediate final : public query_intermediate {

8
include/matador/query/intermediates/query_create_intermediate.hpp
View File

@ -13,11 +13,11 @@ class query_create_intermediate : public query_intermediate {
public:
query_create_intermediate();
executable_query table(const query::table &tab, std::initializer_list<object::attribute_definition> columns);
executable_query table(const query::table &tab, const std::vector<object::attribute_definition> &columns);
executable_query table(const sql::table &table, std::initializer_list<object::attribute_definition> columns);
executable_query table(const sql::table &table, const std::vector<object::attribute_definition> &columns);
template<class Type>
executable_query table(const query::table &tab, const object::repository &schema) {
return this->table(tab, object::attribute_definition_generator::generate<Type>(schema));
executable_query table(const sql::table &table, const object::repository &schema) {
return this->table(table, object::attribute_definition_generator::generate<Type>(schema));
}
executable_query schema(const std::string &schema_name);
};

2
include/matador/query/intermediates/query_delete_intermediate.hpp
View File

@ -12,7 +12,7 @@ class query_delete_intermediate : public query_intermediate
public:
query_delete_intermediate();
query_delete_from_intermediate from(const table &tab);
query_delete_from_intermediate from(const sql::table &table);
};
}

2
include/matador/query/intermediates/query_drop_intermediate.hpp
View File

@ -9,7 +9,7 @@ class query_drop_intermediate : query_intermediate {
public:
query_drop_intermediate();
executable_query table(const table &tab);
executable_query table(const sql::table &table);
executable_query schema(const std::string &schema_name);
};

2
include/matador/query/intermediates/query_execute_where_intermediate.hpp
View File

@ -14,7 +14,7 @@ public:
using executable_query::executable_query;
query_execute_limit_intermediate limit(size_t limit);
query_execute_order_by_intermediate order_by(const column &col);
query_execute_order_by_intermediate order_by(const sql::column &col);
};
}

6
include/matador/query/intermediates/query_from_intermediate.hpp
View File

@ -15,7 +15,7 @@ class query_from_intermediate : public fetchable_query
public:
using fetchable_query::fetchable_query;
query_join_intermediate join_left(const table &t);
query_join_intermediate join_left(const sql::table &t);
query_from_intermediate join_left(join_data &data);
query_from_intermediate join_left(std::vector<join_data> &data_vector);
@ -25,8 +25,8 @@ public:
// return where_clause(std::make_unique<Condition>(std::move(cond)));
// }
query_where_intermediate where(std::unique_ptr<abstract_criteria> &&cond);
query_group_by_intermediate group_by(const column &col);
query_order_by_intermediate order_by(const column &col);
query_group_by_intermediate group_by(const sql::column &col);
query_order_by_intermediate order_by(const sql::column &col);
private:
query_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);

2
include/matador/query/intermediates/query_group_by_intermediate.hpp
View File

@ -12,7 +12,7 @@ class query_group_by_intermediate : public fetchable_query
public:
using fetchable_query::fetchable_query;
query_order_by_intermediate order_by(const column &col);
query_order_by_intermediate order_by(const sql::column &col);
};
}

12
include/matador/query/intermediates/query_insert_intermediate.hpp
View File

@ -14,13 +14,13 @@ public:
query_insert_intermediate();
template<class Type>
query_into_intermediate into(const table &tab, const object::repository &schema) {
return into(tab, generator::columns<Type>(schema));
query_into_intermediate into(const sql::table &table, const object::repository &schema) {
return into(table, generator::columns<Type>(schema));
}
query_into_intermediate into(const table &tab, std::initializer_list<column> columns);
query_into_intermediate into(const table &tab, std::vector<column> &&columns);
query_into_intermediate into(const table &tab, const std::vector<std::string> &column_names);
query_into_intermediate into(const table &tab);
query_into_intermediate into(const sql::table &table, std::initializer_list<sql::column> columns);
query_into_intermediate into(const sql::table &table, std::vector<sql::column> &&columns);
query_into_intermediate into(const sql::table &table, const std::vector<std::string> &column_names);
query_into_intermediate into(const sql::table &table);
};
}

4
include/matador/query/intermediates/query_select_intermediate.hpp
View File

@ -10,9 +10,9 @@ class query_from_intermediate;
class query_select_intermediate : public query_intermediate
{
public:
explicit query_select_intermediate(const std::vector<column>& columns);
explicit query_select_intermediate(const std::vector<sql::column>& columns);
query_from_intermediate from(const table& t);
query_from_intermediate from(const sql::table& t);
};
}

2
include/matador/query/intermediates/query_update_intermediate.hpp
View File

@ -13,7 +13,7 @@ namespace matador::query {
class query_update_intermediate : public query_intermediate {
public:
explicit query_update_intermediate(const table& tab);
explicit query_update_intermediate(const sql::table& table);
query_set_intermediate set(std::initializer_list<internal::column_value_pair> columns);
query_set_intermediate set(std::vector<internal::column_value_pair> &&columns);

4
include/matador/query/intermediates/query_where_intermediate.hpp
View File

@ -13,8 +13,8 @@ class query_where_intermediate : public fetchable_query
public:
using fetchable_query::fetchable_query;
query_group_by_intermediate group_by(const column &col);
query_order_by_intermediate order_by(const column &col);
query_group_by_intermediate group_by(const sql::column &col);
query_order_by_intermediate order_by(const sql::column &col);
};
}

8
include/matador/query/internal/column_value_pair.hpp
View File

@ -1,7 +1,7 @@
#ifndef QUERY_KEY_VALUE_PAIR_HPP
#define QUERY_KEY_VALUE_PAIR_HPP
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
#include "matador/utils/placeholder.hpp"
#include "matador/utils/types.hpp"
@ -10,7 +10,7 @@ namespace matador::query::internal {
class column_value_pair {
public:
column_value_pair(const column &col, utils::database_type value);
column_value_pair(const sql::column &col, utils::database_type value);
column_value_pair(std::string name, utils::database_type value);
column_value_pair(const char *name, utils::database_type value);
column_value_pair(const char *name, utils::placeholder p);
@ -18,11 +18,11 @@ public:
friend bool operator==(const column_value_pair &lhs, const column_value_pair &rhs);
friend bool operator!=(const column_value_pair &lhs, const column_value_pair &rhs);
[[nodiscard]] const column& col() const;
[[nodiscard]] const sql::column& col() const;
[[nodiscard]] const std::variant<utils::placeholder, utils::database_type>& value() const;
private:
column column_;
sql::column column_;
std::variant<utils::placeholder, utils::database_type> value_;
};

100
include/matador/query/internal/query_parts.hpp
View File

@ -6,10 +6,10 @@
#include "matador/query/internal/column_value_pair.hpp"
#include "matador/query/query_part.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table.hpp"
#include "matador/sql/column.hpp"
#include "matador/object/attribute_definition.hpp"
#include "matador/sql/table.hpp"
#include "matador/utils/placeholder.hpp"
@ -26,19 +26,19 @@ public:
class query_alter_table_part final : public query_part {
public:
explicit query_alter_table_part(table tab);
explicit query_alter_table_part(sql::table table);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const table& table() const;
[[nodiscard]] const sql::table& table() const;
private:
query::table table_;
sql::table table_;
};
class query_add_key_constraint_part final : public query_part {
public:
explicit query_add_key_constraint_part(std::string name);
explicit query_add_key_constraint_part(const std::string& name);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::string& name() const;
@ -48,7 +48,7 @@ private:
class query_drop_key_constraint_part final : public query_part {
public:
explicit query_drop_key_constraint_part(std::string name);
explicit query_drop_key_constraint_part(const std::string& name);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::string& name() const;
@ -58,35 +58,35 @@ private:
class query_add_foreign_key_constraint_part final : public query_part {
public:
explicit query_add_foreign_key_constraint_part( const std::vector<column>& columns);
explicit query_add_foreign_key_constraint_part( const std::vector<sql::column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<sql::column>& columns() const;
private:
std::vector<column> columns_;
std::vector<sql::column> columns_;
};
class query_add_foreign_key_reference_part final : public query_part {
public:
explicit query_add_foreign_key_reference_part(table tab, const std::vector<column>& columns);
explicit query_add_foreign_key_reference_part(sql::table table, const std::vector<sql::column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const table& table() const;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const std::vector<sql::column>& columns() const;
private:
query::table table_;
std::vector<column> columns_;
sql::table table_;
std::vector<sql::column> columns_;
};
class query_add_primary_key_constraint_part final : public query_part {
public:
explicit query_add_primary_key_constraint_part( const std::vector<column>& columns);
explicit query_add_primary_key_constraint_part( const std::vector<sql::column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<sql::column>& columns() const;
private:
std::vector<column> columns_;
std::vector<sql::column> columns_;
};
class query_drop_foreign_key_constraint_part final : public query_part {
@ -101,13 +101,13 @@ public:
class query_select_part final : public query_part
{
public:
explicit query_select_part(std::vector<column> columns);
explicit query_select_part(std::vector<sql::column> columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<sql::column>& columns() const;
private:
std::vector<column> columns_;
std::vector<sql::column> columns_;
};
/**
@ -116,29 +116,29 @@ private:
class query_from_part final : public query_part
{
public:
explicit query_from_part(table t);
explicit query_from_part(sql::table t);
[[nodiscard]] const table& table() const;
[[nodiscard]] const sql::table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class table table_;
sql::table table_;
};
class query_join_part final : public query_part
{
public:
explicit query_join_part(table t);
explicit query_join_part(sql::table t);
[[nodiscard]] const table& table() const;
[[nodiscard]] const sql::table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class table table_;
sql::table table_;
};
class query_on_part final : public query_part
@ -189,29 +189,29 @@ protected:
class query_group_by_part final : public query_part
{
public:
explicit query_group_by_part(column col);
explicit query_group_by_part(sql::column col);
[[nodiscard]] const column& column() const;
[[nodiscard]] const sql::column& column() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class column column_;
sql::column column_;
};
class query_order_by_part final : public query_part
{
public:
explicit query_order_by_part(column col);
explicit query_order_by_part(sql::column col);
[[nodiscard]] const column& column() const;
[[nodiscard]] const sql::column& column() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class column column_;
sql::column column_;
};
class query_order_by_asc_part final : public query_part
@ -272,17 +272,17 @@ private:
class query_into_part final : public query_part
{
public:
query_into_part(table t, std::vector<column> columns);
query_into_part(sql::table t, std::vector<sql::column> columns);
[[nodiscard]] const table& table() const;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const std::vector<sql::column>& columns() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class table table_;
std::vector<column> columns_;
sql::table table_;
std::vector<sql::column> columns_;
};
/**
* Represents the SQL VALUES part
@ -304,15 +304,15 @@ private:
class query_update_part final : public query_part
{
public:
explicit query_update_part(table table);
explicit query_update_part(sql::table table);
[[nodiscard]] const table& table() const;
[[nodiscard]] const sql::table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class table table_;
sql::table table_;
};
class query_set_part final : public query_part
@ -341,15 +341,15 @@ private:
class query_delete_from_part final : public query_part
{
public:
explicit query_delete_from_part(table table);
explicit query_delete_from_part(sql::table table);
[[nodiscard]] const table& table() const;
[[nodiscard]] const sql::table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class table table_;
sql::table table_;
};
class query_create_part final : public query_part
@ -364,16 +364,16 @@ private:
class query_create_table_part final : public query_part
{
public:
query_create_table_part(table table, std::vector<object::attribute_definition> columns);
query_create_table_part(sql::table table, std::vector<object::attribute_definition> columns);
[[nodiscard]] const table& table() const;
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const std::vector<object::attribute_definition>& columns() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class table table_;
sql::table table_;
std::vector<object::attribute_definition> columns_;
};
@ -402,15 +402,15 @@ private:
class query_drop_table_part final : public query_part
{
public:
explicit query_drop_table_part(table table);
explicit query_drop_table_part(sql::table table);
[[nodiscard]] const table& table() const;
[[nodiscard]] const sql::table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class table table_;
sql::table table_;
};
class query_drop_schema_part final : public query_part {

4
include/matador/query/join_data.hpp
View File

@ -3,14 +3,14 @@
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/query/table.hpp"
#include "matador/sql/table.hpp"
#include <memory>
namespace matador::query {
struct join_data {
std::shared_ptr<table> join_table;
std::shared_ptr<sql::table> join_table;
std::unique_ptr<abstract_criteria> condition;
};

16
include/matador/query/query.hpp
View File

@ -10,10 +10,10 @@ class connection;
}
namespace matador::query {
column alias(const std::string &column, const std::string &as);
column alias(column &&col, const std::string &as);
column count(const std::string &column);
column count_all();
sql::column alias(const std::string &column, const std::string &as);
sql::column alias(sql::column &&col, const std::string &as);
sql::column count(const std::string &column);
sql::column count_all();
class query
{
@ -21,16 +21,16 @@ public:
[[nodiscard]] static query_create_intermediate create();
[[nodiscard]] static query_drop_intermediate drop();
[[nodiscard]] static query_select_intermediate select();
[[nodiscard]] static query_select_intermediate select(std::initializer_list<column> columns);
[[nodiscard]] static query_select_intermediate select(const std::vector<column>& columns);
[[nodiscard]] static query_select_intermediate select(std::initializer_list<sql::column> columns);
[[nodiscard]] static query_select_intermediate select(const std::vector<sql::column>& columns);
[[nodiscard]] static query_select_intermediate select(const std::vector<std::string> &column_names);
[[nodiscard]] static query_select_intermediate select(std::vector<column> columns, std::initializer_list<column> additional_columns);
[[nodiscard]] static query_select_intermediate select(std::vector<sql::column> columns, std::initializer_list<sql::column> additional_columns);
template<class Type>
[[nodiscard]] static query_select_intermediate select(const object::repository &schema) {
return select(generator::columns<Type>(schema));
}
[[nodiscard]] static query_insert_intermediate insert();
[[nodiscard]] static query_update_intermediate update(const table &table);
[[nodiscard]] static query_update_intermediate update(const sql::table &table);
[[nodiscard]] static query_delete_intermediate remove();
[[nodiscard]] static query_alter_intermediate alter();

3
include/matador/query/query_compiler.hpp
View File

@ -68,7 +68,8 @@ protected:
void visit(internal::query_drop_table_part &part) override;
void visit(internal::query_drop_schema_part& part) override;
static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const table& t);
static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const sql::table& t);
static std::string determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val);
protected:

5
include/matador/query/query_data.hpp
View File

@ -6,7 +6,8 @@
#include "matador/object/attribute_definition.hpp"
#include "matador/query/table.hpp"
#include "matador/sql/table.hpp"
#include "matador/query/query_part.hpp"
namespace matador::query {
@ -14,7 +15,7 @@ namespace matador::query {
struct query_data {
std::vector<std::unique_ptr<query_part>> parts{};
std::vector<object::attribute_definition> columns{};
std::unordered_map<std::string, table> tables{};
std::unordered_map<std::string, sql::table> tables{};
};
}

17
include/matador/query/query_utils.hpp
View File

@ -1,17 +0,0 @@
#ifndef MATADOR_QUERY_UTILS_HPP
#define MATADOR_QUERY_UTILS_HPP
#include "matador/sql/dialect.hpp"
#include <string>
namespace matador::sql {
class dialect;
}
namespace matador::query {
class column;
[[nodiscard]] std::string prepare_identifier(const sql::dialect& d, const column &col);
[[nodiscard]] std::string prepare_criteria(const sql::dialect& d, const column &col);
}
#endif //MATADOR_QUERY_UTILS_HPP

28
include/matador/query/column.hpp → include/matador/sql/column.hpp
View File

@ -1,21 +1,28 @@
#ifndef QUERY_COLUMN_HPP
#define QUERY_COLUMN_HPP
#include "matador/sql/sql_functions.hpp"
#include <functional>
#include <memory>
#include <string>
namespace matador::query {
namespace matador::sql {
class table;
enum class sql_function_t {
None,
Count,
Avg,
Sum,
Min,
Max
};
class column {
public:
column(const char *name, const std::string& as = ""); // NOLINT(*-explicit-constructor)
column(std::string name, std::string as = "");
column(sql::sql_function_t func, std::string name); // NOLINT(*-explicit-constructor)
explicit column(std::string name, std::string as = "");
column(sql_function_t func, std::string name); // NOLINT(*-explicit-constructor)
column(const class table &tab, std::string name, std::string as = "");
column(const std::shared_ptr<table> &t, std::string name, std::string as = "");
@ -27,18 +34,17 @@ public:
[[nodiscard]] std::string full_name() const;
[[nodiscard]] const std::string& alias_name() const;
[[nodiscard]] bool is_function() const;
[[nodiscard]] sql::sql_function_t function() const;
[[nodiscard]] sql_function_t function() const;
[[nodiscard]] bool has_alias() const;
[[nodiscard]] std::string alias() const;
[[nodiscard]] std::shared_ptr<table> table() const;
void table(const std::shared_ptr<query::table>& t);
[[nodiscard]] std::shared_ptr<sql::table> table() const;
void table(const std::shared_ptr<sql::table>& t);
private:
std::shared_ptr<query::table> table_;
std::shared_ptr<sql::table> table_;
std::string name;
std::string alias_;
sql::sql_function_t function_{sql::sql_function_t::None};
sql_function_t function_{sql_function_t::None};
};
column operator ""_col(const char *name, size_t len);

5
include/matador/sql/dialect.hpp
View File

@ -1,8 +1,8 @@
#ifndef QUERY_DIALECT_HPP
#define QUERY_DIALECT_HPP
#include "matador/sql/column.hpp"
#include "matador/sql/dialect_token.hpp"
#include "matador/sql/sql_functions.hpp"
#include "matador/utils/basic_types.hpp"
#include "matador/utils/types.hpp"
@ -42,7 +42,6 @@ public:
public:
[[nodiscard]] const std::string& token_at(dialect_token token) const;
[[nodiscard]] const std::string& data_type_at(utils::basic_type type) const;
[[nodiscard]] const std::string& sql_function_at(sql_function_t func) const;
/**
* Prepare sql dialect identifier for execution
@ -52,7 +51,9 @@ public:
* @param col The identifier string to be prepared
* @return The prepared string
*/
[[nodiscard]] std::string prepare_identifier(const column &col) const;
[[nodiscard]] std::string prepare_identifier_string(const std::string &col) const;
[[nodiscard]] std::string prepare_condition(const column &col) const;
[[nodiscard]] std::string table_name(const std::string &table, const std::string &schema_name) const;
[[nodiscard]] const std::string& to_string(bool val) const;

2
include/matador/sql/interface/connection_impl.hpp
View File

@ -4,10 +4,8 @@
#include <memory>
#include "matador/object/attribute_definition.hpp"
#include "matador/sql/connection_info.hpp"
#include "matador/sql/query_context.hpp"
#include "matador/utils/error.hpp"
#include "matador/utils/result.hpp"
#include "matador/utils/version.hpp"

4
include/matador/sql/query_context.hpp
View File

@ -2,7 +2,7 @@
#define QUERY_QUERY_DATA_HPP
#include "matador/object/attribute_definition.hpp"
#include "matador/query/table.hpp"
#include "matador/sql/table.hpp"
#include "matador/utils/types.hpp"
@ -35,7 +35,7 @@ struct query_context {
sql_command command{};
std::string command_name{};
std::string schema_name{};
std::string table_name{};
sql::table table{""};
std::vector<object::attribute_definition> prototype{};
std::vector<std::string> result_vars{};
std::vector<std::string> bind_vars{};

4
include/matador/sql/query_macro.hpp
View File

@ -3,8 +3,8 @@
#include "matador/utils/macro_map.hpp"
#include "matador/query/table.hpp"
#include "matador/query/column.hpp"
#include "matador/sql/table.hpp"
#include "matador/sql/column.hpp"
#include <string>
#include <ostream>

8
include/matador/sql/record.hpp
View File

@ -8,6 +8,8 @@
namespace matador::sql {
class column;
class record final {
private:
using field_ref = std::reference_wrapper<field>;
@ -39,11 +41,11 @@ public:
[[nodiscard]] const std::vector<field_ref>& columns() const;
[[nodiscard]] const field& at(const std::string &name) const;
[[nodiscard]] const field& at(const sql::column &col) const;
[[nodiscard]] const field& at(size_t index) const;
template<class Type>
std::optional<Type> at(const std::string &name) const {
return at(name).as<Type>();
std::optional<Type> at(const column &col) const {
return at(col).as<Type>();
}
template<class Type>
std::optional<Type> at(const size_t index) const {

14
include/matador/sql/sql_functions.hpp
View File

@ -1,14 +0,0 @@
#ifndef MATADOR_SQL_FUNCTIONS_HPP
#define MATADOR_SQL_FUNCTIONS_HPP
namespace matador::sql {
enum class sql_function_t {
None,
Count,
Avg,
Sum,
Min,
Max
};
}
#endif //MATADOR_SQL_FUNCTIONS_HPP

4
include/matador/query/table.hpp → include/matador/sql/table.hpp
View File

@ -1,12 +1,12 @@
#ifndef QUERY_TABLE_HPP
#define QUERY_TABLE_HPP
#include "column.hpp"
#include "matador/sql/column.hpp"
#include <string>
#include <vector>
namespace matador::query {
namespace matador::sql {
class column;

18
source/orm/CMakeLists.txt
View File

@ -4,8 +4,6 @@ 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
@ -18,7 +16,6 @@ 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
@ -56,11 +53,10 @@ 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
@ -81,16 +77,14 @@ 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
@ -100,7 +94,6 @@ 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
@ -136,16 +129,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
@ -158,6 +151,9 @@ 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

8
source/orm/orm/session.cpp
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({data.root_table, data.pk_column_name})
.order_by(sql::column{data.root_table, data.pk_column_name})
.asc();
}
}

8
source/orm/orm/session_query_builder.cpp
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<query::table>>& tables_by_name)
criteria_transformer::criteria_transformer(const object::repository& repo, const std::unordered_map<std::string, std::shared_ptr<sql::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.col().table()->name());
const auto it = tables_by_name_.find(node.column().table()->name());
if (it == tables_by_name_.end()) {
return;
}
const_cast<query::column&>(node.col()).table(it->second);
const_cast<sql::column&>(node.column()).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 query::column &left, const query::column &right) {
void session_query_builder::append_join(const sql::column &left, const sql::column &right) {
using namespace matador::query;
entity_query_data_.joins.push_back({
{right.table()},

62
source/orm/query/builder.cpp
View File

@ -1,62 +0,0 @@
#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));
}
}

6
source/orm/query/criteria/abstract_column_criteria.cpp
View File

@ -1,10 +1,10 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
namespace matador::query {
abstract_column_criteria::abstract_column_criteria(column col)
: column_(std::move(col)) {}
abstract_column_criteria::abstract_column_criteria(sql::column column)
: column_(std::move(column)) {}
const column& abstract_column_criteria::col() const {
const sql::column& abstract_column_criteria::column() const {
return column_;
}
}

8
source/orm/query/criteria/between_criteria.cpp
View File

@ -3,14 +3,14 @@
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query{
between_criteria::between_criteria(column col, const int64_t min, const int64_t max)
: abstract_column_criteria(std::move(col))
between_criteria::between_criteria(sql::column column, const int64_t min, const int64_t max)
: abstract_column_criteria(std::move(column))
, min_(utils::value{min})
, max_(utils::value{max})
{}
between_criteria::between_criteria(column col, utils::placeholder min, utils::placeholder max)
: abstract_column_criteria(std::move(col))
between_criteria::between_criteria(sql::column column, utils::placeholder min, utils::placeholder max)
: abstract_column_criteria(std::move(column))
, min_(min)
, max_(max)
{}

10
source/orm/query/criteria/binary_criteria.cpp
View File

@ -3,8 +3,8 @@
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
binary_criteria::binary_criteria(column col, const binary_operator operand, criteria_value value)
: abstract_column_criteria(std::move(col))
binary_criteria::binary_criteria(sql::column column, const binary_operator operand, criteria_value value)
: abstract_column_criteria(std::move(column))
, 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(column left_column, binary_operator operand, column right_column)
binary_column_criteria::binary_column_criteria( sql::column left_column, binary_operator operand, sql::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 column& binary_column_criteria::left_column() const {
const sql::column& binary_column_criteria::left_column() const {
return left_column_;
}
@ -38,7 +38,7 @@ binary_operator binary_column_criteria::operand() const {
return operator_;
}
const column& binary_column_criteria::right_column() const {
const sql::column& binary_column_criteria::right_column() const {
return right_column_;
}
}

6
source/orm/query/criteria/collection_criteria.cpp
View File

@ -3,13 +3,13 @@
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
collection_criteria::collection_criteria(column col, const collection_operator operand_, std::vector<criteria_value> values )
collection_criteria::collection_criteria(sql::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(column col, const collection_operator operand_, const std::initializer_list<criteria_value> values )
collection_criteria::collection_criteria(sql::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(column col, collection_operator operand_, sql::query_context ctx)
collection_query_criteria::collection_query_criteria(sql::column col, collection_operator operand_, sql::query_context ctx)
: abstract_column_criteria(std::move(col))
, operand_(operand_)
, query_context_(std::move(ctx)){

38
source/orm/query/criteria/criteria_operators.cpp
View File

@ -6,51 +6,51 @@
#include "matador/query/criteria/not_criteria.hpp"
namespace matador::query {
criteria_ptr operator==(const column &col, utils::placeholder p) {
criteria_ptr operator==(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, p);
}
criteria_ptr operator!=(const column &col, utils::placeholder p) {
criteria_ptr operator!=(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, p);
}
criteria_ptr operator>(const column &col, utils::placeholder p) {
criteria_ptr operator>(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, p);
}
criteria_ptr operator>=(const column &col, utils::placeholder p) {
criteria_ptr operator>=(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, p);
}
criteria_ptr operator<(const column &col, utils::placeholder p) {
criteria_ptr operator<(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, p);
}
criteria_ptr operator<=(const column &col, utils::placeholder p) {
criteria_ptr operator<=(const sql::column &col, utils::placeholder p) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, p);
}
criteria_ptr operator==( const column& col_left, const column& col_right ) {
criteria_ptr operator==( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::EQUALS, col_right);
}
criteria_ptr operator!=( const column& col_left, const column& col_right ) {
criteria_ptr operator!=( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::NOT_EQUALS, col_right);
}
criteria_ptr operator>( const column& col_left, const column& col_right ) {
criteria_ptr operator>( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN, col_right);
}
criteria_ptr operator>=( const column& col_left, const column& col_right ) {
criteria_ptr operator>=( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::GREATER_THAN_OR_EQUAL, col_right);
}
criteria_ptr operator<( const column& col_left, const column& col_right ) {
criteria_ptr operator<( const sql::column& col_left, const sql::column& col_right ) {
return std::make_unique<binary_column_criteria>(col_left, binary_operator::LESS_THAN, col_right);
}
criteria_ptr operator<=( const column& col_left, const column& col_right ) {
criteria_ptr operator<=( const sql::column& col_left, const sql::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 column &col, const std::initializer_list<utils::placeholder> args) {
criteria_ptr in(const sql::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 column &col, const std::initializer_list<utils::placeholde
return std::make_unique<collection_criteria>(col, collection_operator::In, std::move(values));
}
criteria_ptr in(const column &col, sql::query_context &&ctx) {
criteria_ptr in(const sql::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 column &col, const std::initializer_list<utils::placeholder> args) {
criteria_ptr out(const sql::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 column &col, const std::initializer_list<utils::placehold
return std::make_unique<collection_criteria>(col, collection_operator::Out, values);
}
criteria_ptr out(const column &col, sql::query_context &&ctx) {
criteria_ptr out(const sql::column &col, sql::query_context &&ctx) {
return std::make_unique<collection_query_criteria>(col, collection_operator::In, std::move(ctx));
}
criteria_ptr between(const column &col, const int64_t min, const int64_t max) {
criteria_ptr between(const sql::column &col, const int64_t min, const int64_t max) {
return std::make_unique<between_criteria>(col, min, max);
}
criteria_ptr between(const column &col, utils::placeholder min, utils::placeholder max) {
criteria_ptr between(const sql::column &col, utils::placeholder min, utils::placeholder max) {
return std::make_unique<between_criteria>(col, min, max);
}
criteria_ptr like(const column &col, const std::string &pattern) {
criteria_ptr like(const sql::column &col, const std::string &pattern) {
return std::make_unique<like_criteria>(col, pattern);
}
}

4
source/orm/query/criteria/like_criteria.cpp
View File

@ -3,8 +3,8 @@
#include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query {
like_criteria::like_criteria(column col, std::string pattern)
: abstract_column_criteria(std::move(col))
like_criteria::like_criteria(sql::column column, std::string pattern)
: abstract_column_criteria(std::move(column))
, pattern_(std::move(pattern)){}
void like_criteria::accept(criteria_visitor &visitor) const {

21
source/orm/query/criteria_evaluator.cpp
View File

@ -1,6 +1,5 @@
#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"
@ -39,9 +38,9 @@ std::string criteria_evaluator::evaluate(const abstract_criteria &node) {
}
void criteria_evaluator::visit(const between_criteria &node) {
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) + " ";
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) + " ";
evaluate_value(node.minimum());
clause_ += " " + dialect_.token_at(sql::dialect_token::And) + " ";
evaluate_value(node.maximum());
@ -51,23 +50,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.col().column_name());
clause_ += prepare_criteria(dialect_, node.col()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " ";
query_.bind_vars.emplace_back(node.column().column_name());
clause_ += dialect_.prepare_condition(node.column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " ";
evaluate_value(node.value());
}
void criteria_evaluator::visit( const binary_column_criteria& node ) {
clause_ += prepare_criteria(dialect_, node.left_column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " " + prepare_criteria(dialect_, node.right_column());
clause_ += dialect_.prepare_condition(node.left_column()) + " " + detail::BinaryOperatorEnum.to_string(node.operand()) + " " + dialect_.prepare_condition(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.col().column_name());
query_.bind_vars.emplace_back(node.column().column_name());
}
clause_ += prepare_identifier(dialect_, node.col()) +
clause_ += dialect_.prepare_identifier(node.column()) +
(node.operand() == collection_operator::Out ? " " + dialect_.token_at(sql::dialect_token::Not) + " " : " ") +
dialect_.token_at(sql::dialect_token::In) + " (";
if (node.values().size() < 2) {
@ -86,13 +85,13 @@ void criteria_evaluator::visit(const collection_criteria &node) {
}
void criteria_evaluator::visit(const collection_query_criteria &node) {
clause_ += prepare_identifier(dialect_, node.col()) +
clause_ += dialect_.prepare_identifier(node.column()) +
(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_ += prepare_criteria(dialect_, node.col()) + " " + dialect_.token_at(sql::dialect_token::Like) +
clause_ += dialect_.prepare_condition(node.column()) + " " + dialect_.token_at(sql::dialect_token::Like) +
" " + dialect_.token_at(sql::dialect_token::BeginStringData) + node.pattern() + dialect_.token_at(
sql::dialect_token::EndStringData);
}

4
source/orm/query/generator.cpp
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<table>() : std::make_shared<table>(table_name));
table_stack_.push(table_name.empty() ? std::make_shared<sql::table>() : std::make_shared<sql::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<table>() : std::make_shared<table>(table_name));
table_stack_.push(table_name.empty() ? std::make_shared<sql::table>() : std::make_shared<sql::table>(table_name));
}
void column_generator::on_revision( const char* id, uint64_t& ) {

4
source/orm/query/intermediates/query_alter_intermediate.cpp
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 class table& tab) const {
context_->parts.push_back(std::make_unique<internal::query_alter_table_part>(tab));
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));
return {context_};
}
}

16
source/orm/query/intermediates/query_alter_table_intermediate.cpp
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 table& tab, const std::vector<column>& columns) {
context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_reference_part>(tab, columns));
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));
return {context_};
}
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_key(const sql::column& column) const {
return primary_keys({column});
}
query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<column>& columns) const {
query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<sql::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 column& col) const {
return foreign_keys({col});
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_keys(const std::vector<column>& columns) const {
query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys( const std::vector<sql::column>& columns ) const {
context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_constraint_part>(columns));
return {context_};

8
source/orm/query/intermediates/query_create_intermediate.cpp
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 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::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::vector<object::attribute_definition> &columns) {
context_->parts.push_back(std::make_unique<internal::query_create_table_part>(tab, 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));
return {context_};
}

8
source/orm/query/intermediates/query_delete_intermediate.cpp
View File

@ -6,12 +6,14 @@
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 table &tab) {
context_->parts.push_back(std::make_unique<internal::query_delete_from_part>(tab));
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));
return {context_};
}

4
source/orm/query/intermediates/query_drop_intermediate.cpp
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 class table &tab) {
context_->parts.push_back(std::make_unique<internal::query_drop_table_part>(tab));
executable_query query_drop_intermediate::table(const sql::table &table) {
context_->parts.push_back(std::make_unique<internal::query_drop_table_part>(table));
return {context_};
}

6
source/orm/query/intermediates/query_execute_where_intermediate.cpp
View File

@ -7,12 +7,14 @@
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 column &col) {
query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const sql::column &col)
{
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_};
}

6
source/orm/query/intermediates/query_from_intermediate.cpp
View File

@ -8,7 +8,7 @@
namespace matador::query {
query_join_intermediate query_from_intermediate::join_left(const table &t) {
query_join_intermediate query_from_intermediate::join_left(const sql::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 column &col) {
query_group_by_intermediate query_from_intermediate::group_by(const sql::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 column &col) {
query_order_by_intermediate query_from_intermediate::order_by(const sql::column &col) {
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_};
}

3
source/orm/query/intermediates/query_group_by_intermediate.cpp
View File

@ -5,7 +5,8 @@
namespace matador::query {
query_order_by_intermediate query_group_by_intermediate::order_by(const column &col) {
query_order_by_intermediate query_group_by_intermediate::order_by(const sql::column &col)
{
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_};
}

23
source/orm/query/intermediates/query_insert_intermediate.cpp
View File

@ -6,30 +6,33 @@
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 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, 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, std::vector<column> &&columns) {
context_->parts.push_back(std::make_unique<internal::query_into_part>(tab, 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));
return {context_};
}
query_into_intermediate query_insert_intermediate::into(const table &tab, const std::vector<std::string> &column_names) {
std::vector<column> columns;
query_into_intermediate query_insert_intermediate::into(const sql::table &table, const std::vector<std::string> &column_names) {
std::vector<sql::column> columns;
columns.reserve(column_names.size());
for (const auto &col_name : column_names) {
columns.emplace_back(col_name);
}
return into(tab, std::move(columns));
return into(table, std::move(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()));
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()));
return {context_};
}

6
source/orm/query/intermediates/query_select_intermediate.cpp
View File

@ -6,11 +6,13 @@
namespace matador::query {
query_select_intermediate::query_select_intermediate(const std::vector<column>& columns) {
query_select_intermediate::query_select_intermediate(const std::vector<sql::column>& columns)
{
context_->parts.push_back(std::make_unique<internal::query_select_part>(columns));
}
query_from_intermediate query_select_intermediate::from(const table& t) {
query_from_intermediate query_select_intermediate::from(const sql::table& t)
{
context_->parts.push_back(std::make_unique<internal::query_from_part>(t));
context_->tables.insert({t.name(), t});
return {context_};

11
source/orm/query/intermediates/query_update_intermediate.cpp
View File

@ -4,15 +4,18 @@
namespace matador::query {
query_update_intermediate::query_update_intermediate(const table& tab) {
context_->parts.push_back(std::make_unique<internal::query_update_part>(tab));
query_update_intermediate::query_update_intermediate(const sql::table& table)
{
context_->parts.push_back(std::make_unique<internal::query_update_part>(table));
}
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_};
}

6
source/orm/query/intermediates/query_where_intermediate.cpp
View File

@ -6,12 +6,14 @@
namespace matador::query {
query_group_by_intermediate query_where_intermediate::group_by(const column &col) {
query_group_by_intermediate query_where_intermediate::group_by(const sql::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 column &col) {
query_order_by_intermediate query_where_intermediate::order_by(const sql::column &col)
{
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_};
}

4
source/orm/query/internal/column_value_pair.cpp
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 column &col, utils::database_type value)
column_value_pair::column_value_pair(const sql::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 column &column_value_pair::col() const {
const sql::column &column_value_pair::col() const {
return column_;
}

74
source/orm/query/internal/query_parts.cpp
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(class table tab)
query_alter_table_part::query_alter_table_part(sql::table table )
: query_part(sql::dialect_token::Table)
, table_(std::move(tab)) {}
, table_(std::move(table)) {}
void query_alter_table_part::accept(query_part_visitor& visitor) {
void query_alter_table_part::accept( query_part_visitor& visitor ) {
visitor.visit(*this);
}
const table& query_alter_table_part::table() const {
const sql::table& query_alter_table_part::table() const {
return table_;
}
query_add_key_constraint_part::query_add_key_constraint_part(std::string name)
query_add_key_constraint_part::query_add_key_constraint_part(const std::string& name)
: query_part(sql::dialect_token::AddConstraint)
, name_(std::move(name)){}
, name_(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(std::string name)
query_drop_key_constraint_part::query_drop_key_constraint_part( const std::string& name )
: query_part( sql::dialect_token::DropConstraint )
, name_(std::move( name )){}
, name_( 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<column>& columns)
query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<sql::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<column>& query_add_foreign_key_constraint_part::columns() const {
const std::vector<sql::column>& query_add_foreign_key_constraint_part::columns() const {
return columns_;
}
query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<column>& columns)
query_add_foreign_key_reference_part::query_add_foreign_key_reference_part( sql::table table, const std::vector<sql::column>& columns )
: query_part(sql::dialect_token::References)
, table_(std::move(tab))
, table_(std::move(table))
, columns_(columns) {}
void query_add_foreign_key_reference_part::accept( query_part_visitor& visitor ) {
visitor.visit(*this);
}
const table& query_add_foreign_key_reference_part::table() const {
const sql::table& query_add_foreign_key_reference_part::table() const {
return table_;
}
const std::vector<column>& query_add_foreign_key_reference_part::columns() const {
const std::vector<sql::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<column>& columns)
query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<sql::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<column>& query_add_primary_key_constraint_part::columns() const {
const std::vector<sql::column>& query_add_primary_key_constraint_part::columns() const {
return columns_;
}
query_select_part::query_select_part(std::vector<column> columns)
query_select_part::query_select_part(std::vector<sql::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<column>& query_select_part::columns() const
const std::vector<sql::column>& query_select_part::columns() const
{
return columns_;
}
query_from_part::query_from_part(class table t)
query_from_part::query_from_part(sql::table t)
: query_part(sql::dialect_token::From)
, table_(std::move(t)) {}
const table &query_from_part::table() const
const sql::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(class table t)
query_join_part::query_join_part(sql::table t)
: query_part(sql::dialect_token::Join)
, table_(std::move(t)) {}
const table &query_join_part::table() const
const sql::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(class column col)
query_group_by_part::query_group_by_part(sql::column col)
: query_part(sql::dialect_token::GroupBy)
, column_(std::move(col))
{}
const column &query_group_by_part::column() const
const sql::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(class column col)
query_order_by_part::query_order_by_part(sql::column col)
: query_part(sql::dialect_token::OrderBy)
, column_(std::move(col))
{}
const column &query_order_by_part::column() const
const sql::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(class table t, std::vector<column> columns)
query_into_part::query_into_part(sql::table t, std::vector<sql::column> columns)
: query_part(sql::dialect_token::Insert)
, table_(std::move(t))
, columns_(std::move(columns)) {}
const table &query_into_part::table() const
const sql::table &query_into_part::table() const
{
return table_;
}
const std::vector<column> &query_into_part::columns() const
const std::vector<sql::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(class table table)
query_update_part::query_update_part(sql::table table)
: query_part(sql::dialect_token::Update)
, table_(std::move(table)) {}
const table& query_update_part::table() const
const sql::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(class table table)
query_delete_from_part::query_delete_from_part(sql::table table)
: query_part(sql::dialect_token::From)
, table_(std::move(table)) {}
const table &query_delete_from_part::table() const
const sql::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(class table table, std::vector<object::attribute_definition> columns)
query_create_table_part::query_create_table_part(sql::table table, std::vector<object::attribute_definition> columns)
: query_part(sql::dialect_token::Table)
, table_(std::move(table))
, columns_(std::move(columns)) {}
const table &query_create_table_part::table() const
const sql::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(class table table)
query_drop_table_part::query_drop_table_part(sql::table table)
: query_part(sql::dialect_token::Table)
, table_(std::move(table)) {}
const table &query_drop_table_part::table() const
const sql::table &query_drop_table_part::table() const
{
return table_;
}

26
source/orm/query/query.cpp
View File

@ -2,20 +2,24 @@
namespace matador::query {
column alias(const std::string &column, const std::string &as) {
return {column, as};
sql::column alias(const std::string &column, const std::string &as)
{
return sql::column{column, as};
}
column alias(column &&col, const std::string &as) {
sql::column alias(sql::column &&col, const std::string &as)
{
col.as(as);
return std::move(col);
}
column count(const std::string &column) {
sql::column count(const std::string &column)
{
return {sql::sql_function_t::Count, column};
}
column count_all() {
sql::column count_all()
{
return count("*");
}
@ -32,16 +36,16 @@ query_select_intermediate query::select() {
return query_select_intermediate{{}};
}
query_select_intermediate query::select( const std::initializer_list<column> columns) {
return select(std::vector<column>{columns});
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::vector<column>& columns) {
query_select_intermediate query::select(const std::vector<sql::column>& columns) {
return query_select_intermediate{columns};
}
query_select_intermediate query::select(const std::vector<std::string> &column_names) {
std::vector<column> columns;
std::vector<sql::column> columns;
columns.reserve(column_names.size());
for (const auto &col_name : column_names) {
columns.emplace_back(col_name);
@ -49,7 +53,7 @@ query_select_intermediate query::select(const std::vector<std::string> &column_n
return select(columns);
}
query_select_intermediate query::select(std::vector<column> columns, const std::initializer_list<column> additional_columns) {
query_select_intermediate query::select(std::vector<sql::column> columns, const std::initializer_list<sql::column> additional_columns) {
for (const auto &col : additional_columns) {
columns.push_back(col);
}
@ -60,7 +64,7 @@ query_insert_intermediate query::insert() {
return {};
}
query_update_intermediate query::update(const table &table) {
query_update_intermediate query::update(const sql::table &table) {
return query_update_intermediate{table};
}

46
source/orm/query/query_compiler.cpp
View File

@ -1,11 +1,8 @@
#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"
@ -36,7 +33,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 column &col) {
std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const sql::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()});
@ -48,10 +45,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 prepare_identifier(*d, {it->second, col.column_name(), col.alias()});
return d->prepare_identifier({it->second, col.column_name(), col.alias()});
}
return prepare_identifier(*d, col);
return d->prepare_identifier(col);
}
void query_compiler::visit(internal::query_alter_part& part) {
@ -137,10 +134,11 @@ void query_compiler::visit(internal::query_select_part &part)
query_.sql += result;
}
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_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_join_part &part)
@ -161,13 +159,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) + " " + prepare_identifier(*dialect_, part.column());
query_.sql += " " + dialect_->token_at(sql::dialect_token::GroupBy) + " " + dialect_->prepare_identifier(part.column());
}
void query_compiler::visit(internal::query_order_by_part &part)
{
query_.sql += " " + dialect_->token_at(sql::dialect_token::OrderBy) +
" " + prepare_criteria(*dialect_, part.column());
" " + dialect_->prepare_condition(part.column());
}
void query_compiler::visit(internal::query_order_by_asc_part &/*order_by_asc_part*/)
@ -198,7 +196,7 @@ void query_compiler::visit(internal::query_insert_part &/*insert_part*/)
void query_compiler::visit(internal::query_into_part &part)
{
query_.table_name = part.table().name();
query_.table = part.table();
query_.sql += " " + dialect_->token_at(sql::dialect_token::Into) +
" " + dialect_->prepare_identifier_string(part.table().name());
@ -269,8 +267,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_name = part.table().name();
query_.sql += query_compiler::build_table_name(part.token(), *dialect_, query_.table_name);
query_.table = part.table();
query_.sql += query_compiler::build_table_name(part.token(), *dialect_, query_.table);
}
void query_compiler::visit(internal::query_delete_part &/*delete_part*/)
@ -281,8 +279,8 @@ void query_compiler::visit(internal::query_delete_part &/*delete_part*/)
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);
query_.table = part.table();
query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table);
}
void query_compiler::visit(internal::query_create_part &/*create_part*/)
@ -307,7 +305,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_name = part.table().name();
query_.table = part.table();
std::string result = "(";
@ -331,11 +329,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->object()->name() + "(" + reference_column->name() + ")";
fk_cmd += " REFERENCES " + reference_column->table_name() + "(" + reference_column->name() + ")";
query_.additional_commands.push_back({fk_cmd, sql::sql_command::SQL_ALTER_TABLE});
}
@ -385,8 +383,8 @@ void query_compiler::visit(internal::query_set_part &part) {
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);
query_.table = part.table();
query_.sql += " " + query_compiler::build_table_name(part.token(), *dialect_, query_.table);
}
std::string build_create_column(const object::attribute_definition &col, const sql::dialect &d, column_context &context)
@ -411,7 +409,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 table& t)
std::string query_compiler::build_table_name(const sql::dialect_token token, const sql::dialect &d, const sql::table& t)
{
return d.token_at(token) + " " +
(!d.default_schema_name().empty() ? d.prepare_identifier_string(d.default_schema_name()) + "." : "") +

39
source/orm/query/query_utils.cpp
View File

@ -1,39 +0,0 @@
#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;
}
}

25
source/orm/query/column.cpp → source/orm/sql/column.cpp
View File

@ -1,11 +1,12 @@
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
#include "matador/query/table.hpp"
#include "matador/sql/table.hpp"
#include <stdexcept>
#include <utility>
namespace matador::query {
namespace matador::sql {
column operator ""_col(const char *name, size_t len) {
const std::string str(name, len);
@ -26,23 +27,23 @@ column::column(const char *name, const std::string& as)
{}
column::column(std::string name, std::string as)
: table_(std::make_shared<query::table>())
: table_(std::make_shared<sql::table>())
, name(std::move(name))
, alias_(std::move(as)) {}
column::column(const sql::sql_function_t func, std::string name)
: table_(std::make_shared<query::table>())
column::column(const sql_function_t func, std::string name)
: table_(std::make_shared<sql::table>())
, name(std::move(name))
, function_(func) {}
column::column(const query::table& tab, std::string name, std::string as)
: table_(std::make_shared<query::table>(tab))
column::column(const sql::table& tab, std::string name, std::string as)
: table_(std::make_shared<sql::table>(tab))
, name(std::move(name))
, alias_(std::move(as)) {
table_->columns_.push_back(*this);
}
column::column(const std::shared_ptr<query::table>& t, std::string name, std::string as)
column::column(const std::shared_ptr<sql::table>& t, std::string name, std::string as)
: table_(t)
, name(std::move(name))
, alias_(std::move(as)) {
@ -76,10 +77,10 @@ const std::string& column::alias_name() const {
}
bool column::is_function() const {
return function_ != sql::sql_function_t::None;
return function_ != sql_function_t::None;
}
sql::sql_function_t column::function() const {
sql_function_t column::function() const {
return function_;
}
@ -95,7 +96,7 @@ std::shared_ptr<table> column::table() const {
return table_;
}
void column::table( const std::shared_ptr<query::table>& t ) {
void column::table( const std::shared_ptr<sql::table>& t ) {
table_ = t;
}
}

2
source/orm/sql/connection.cpp
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),

42
source/orm/sql/dialect.cpp
View File

@ -6,16 +6,31 @@
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);
}
const std::string& dialect::sql_function_at(const sql_function_t func) const {
return sql_func_map_.at(func);
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;
}
std::string dialect::table_name( const std::string& table, const std::string& schema_name ) const {
@ -28,6 +43,25 @@ 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)];

4
source/orm/sql/executor.cpp Normal file
View File

@ -0,0 +1,4 @@
#include "matador/sql/executor.hpp"
namespace matador::sql {
}

6
source/orm/sql/record.cpp
View File

@ -1,4 +1,5 @@
#include "matador/sql/record.hpp"
#include "matador/sql/column.hpp"
#include <algorithm>
#include <stdexcept>
@ -66,8 +67,9 @@ const std::vector<record::field_ref> &record::columns() const
// return columns_[pk_index_];
//}
const field &record::at(const std::string &name) const {
const auto &res = fields_by_name_.at(name);
const field &record::at(const sql::column &col) const
{
const auto &res = fields_by_name_.at(col.column_name());
const auto &f = res.first;
return f;
}

4
source/orm/query/table.cpp → source/orm/sql/table.cpp
View File

@ -1,6 +1,6 @@
#include "matador/query/table.hpp"
#include "matador/sql/table.hpp"
namespace matador::query {
namespace matador::sql {
table::table(const char* name)
: table(std::string(name))

2
test/backends/QueryRecordTest.cpp
View File

@ -1,10 +1,10 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/sql/column.hpp"
#include "matador/sql/connection.hpp"
#include "matador/query/criteria.hpp"
#include "matador/query/query.hpp"
#include "matador/query/column.hpp"
#include "matador/utils/types.hpp"
#include "matador/utils/string.hpp"

2
test/backends/QueryStatementTests.cpp
View File

@ -1,10 +1,10 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/sql/column.hpp"
#include "matador/sql/connection.hpp"
#include "matador/query/criteria.hpp"
#include "matador/query/query.hpp"
#include "matador/query/column.hpp"
#include "models/person.hpp"

4
test/orm/orm/SessionQueryBuilderTest.cpp
View File

@ -3,11 +3,11 @@
#include "matador/sql/backend_provider.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/column.hpp"
#include "matador/sql/table.hpp"
#include "matador/query/criteria_evaluator.hpp"
#include "matador/query/query.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table.hpp"
#include "matador/orm/session_query_builder.hpp"

4
test/orm/query/GeneratorTests.cpp
View File

@ -1,13 +1,15 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/query/generator.hpp"
#include "matador/query/column.hpp"
#include "matador/sql/column.hpp"
#include "../../models/airplane.hpp"
#include "../../models/flight.hpp"
using namespace matador::utils;
using namespace matador::query;
using namespace matador::sql;
using namespace matador::test;
TEST_CASE("Test placeholder generator", "[generator][placeholder]") {

2
test/orm/query/QueryBuilderTest.cpp
View File

@ -4,11 +4,11 @@
#include <matador/query/criteria.hpp>
#include <matador/query/query.hpp>
#include "matador/query/table.hpp"
#include "matador/object/attribute_definition_generator.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/table.hpp"
#include "matador/utils/placeholder.hpp"

3
test/orm/sql/ColumnGeneratorTest.cpp
View File

@ -1,7 +1,6 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/query/generator.hpp"
#include "matador/query/table.hpp"
#include "matador/object/repository.hpp"
@ -9,7 +8,9 @@
#include "../test/models/order.hpp"
#include "../test/models/book.hpp"
#include "../test/models/author.hpp"
#include "matador/sql/table.hpp"
using namespace matador::sql;
using namespace matador::query;
using namespace matador::object;

89
todo.md
View File

@ -1,89 +0,0 @@
# Todo
- replace mk_column with builder style (see `query/builder.hpp`)
- fix corresponding tests
- enhance query helper macro to look like the `book` class below
- add `aliasable_table`(see class below)
- add `as()` methode to table class
- move `sql_function_t` to own header in namespace `matador::sql`
- move `prepare_*` methods from `dialect` to `query_compiler`
- add `session_insert_builder` and `session_update_builder` (returning multiple statements)
- finish `attribued_definition` (also in `repository` class -> dependencies)
- fix compile errors
- finish fetch eager has-many/belongs-to relations
- implement lazy loading
- implement polymorphic class hierarchies
- finish `schema` and `schema_repository` classes (move add/drop from `session` to `schema`)
## book class
```cpp
class book : public matador::sql::aliasable_table<Book> {
public:
using aliasable_table::as;
Book() : aliasable_table("book", "") {}
private:
friend class aliasable_table;
explicit Book(std::string alias)
: aliasable_table("book", std::move(alias)) {}
public:
matador::sql::column id = create_column("id", *this);
matador::sql::column title = create_column("title", *this);
matador::sql::column year = create_column("year", *this);
};
```
## aliasable_table
```cpp
class table {
public:
using iterator = std::vector<column>::iterator;
using const_iterator = std::vector<column>::const_iterator;
explicit table(std::string name) : name_(std::move(name)) {}
table(std::string name, std::vector<column> columns)
: name_(std::move(name)), columns_(std::move(columns)) {}
void add_column(column column) {
column.table_ = shared_from_this();
columns_.emplace_back(std::move(column));
}
static const column& create_column(std::string name, table& t) {
column c{std::move(name)};
c.table_ = &t;
t.columns_.emplace_back(std::move(c));
return t.columns_.back();
}
operator const std::vector<column>&() const { return columns_; }
table as_table() const { return {name_, columns_}; }
iterator begin() { return columns_.begin(); }
iterator end() { return columns_.end(); }
[[nodiscard]] bool empty() const { return columns_.empty(); }
[[nodiscard]] size_t size() const { return columns_.size(); }
[[nodiscard]] const std::string& name() const { return name_; }
[[nodiscard]] const std::vector<column>& columns() const { return columns_; }
private:
std::string name_;
std::vector<column> columns_;
};
template < typename Type >
class aliasable_table : public table {
public:
aliasable_table(std::string name, std::string alias)
: table(std::move(name))
, alias_(std::move(alias)) {}
Type as(std::string alias) { return Type{std::move(alias)}; }
private:
std::string alias_;
};
```