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

moved column and table class from namespace sql to query

Browse Source
This commit is contained in:
Sascha Kühl
2025-11-18 16:27:38 +01:00
parent 7242dc2612
commit fb4bc03da0
79 changed files with 626 additions and 496 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/matador/orm/session_query_builder.hpp
+27 -27
View File
@@ -23,9 +23,9 @@
namespace matador::orm {
struct entity_query_data {
std::shared_ptr<sql::table> root_table;
std::shared_ptr<query::table> root_table;
std::string pk_column_name{};
std::vector<sql::column> columns{};
std::vector<query::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<sql::table>>& tables_by_name);
criteria_transformer(const object::repository &repo, const std::unordered_map<std::string, std::shared_ptr<query::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<sql::table>>& tables_by_name_;
const std::unordered_map<std::string, std::shared_ptr<query::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<sql::table>(info.value().get().name(), build_alias('t', ++table_index))});
table_info_stack_.push({info.value(), std::make_shared<query::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<sql::table>(info->get().name(), build_alias('t', ++table_index))});
table_info_stack_.push({info.value(), std::make_shared<query::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(
sql::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
sql::column{next->second, join_column}
query::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
query::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<sql::table>(id, build_alias('t', ++table_index))}).first;
relation = processed_tables_.insert({id, std::make_shared<query::table>(id, build_alias('t', ++table_index))}).first;
}
table_info_stack_.push({info.value(), std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index))});
table_info_stack_.push({info.value(), std::make_shared<query::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(
sql::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
sql::column{relation->second, join_column}
query::column{table_info_stack_.top().table, table_info_stack_.top().info.get().definition().primary_key()->name()},
query::column{relation->second, join_column}
);
append_join(
sql::column{relation->second, inverse_join_column},
sql::column{next->second, pk->name()}
query::column{relation->second, inverse_join_column},
query::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<sql::table>(id, build_alias('t', ++table_index))}).first;
relation = processed_tables_.insert({id, std::make_shared<query::table>(id, build_alias('t', ++table_index))}).first;
}
table_info_stack_.push({info.value(), std::make_shared<sql::table>(info->get().name(), build_alias('t', ++table_index))});
table_info_stack_.push({info.value(), std::make_shared<query::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(
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}
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}
);
append_join(
sql::column{relation->second, join_columns.join_column},
sql::column{next->second, pk->name()}
query::column{relation->second, join_columns.join_column},
query::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 sql::column &left, const sql::column &right);
void append_join(const query::column &left, const query::column &right);
private:
struct table_info {
std::reference_wrapper<const object::basic_object_info> info;
std::shared_ptr<sql::table> table;
std::shared_ptr<query::table> table;
};
std::stack<table_info> table_info_stack_{};
std::unordered_map<std::string, std::shared_ptr<sql::table>> processed_tables_{};
std::unordered_map<std::string, std::shared_ptr<query::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<sql::table>(info->get().name(), build_alias('t', ++table_index));
const auto foreign_table = std::make_shared<query::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(
sql::column{table_info_stack_.top().table, id},
sql::column{next->second, pk->name()}
query::column{table_info_stack_.top().table, id},
query::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(sql::column(foreign_table, pk->name(), "") == _)
.where(column(foreign_table, pk->name(), "") == _)
.prepare(executor_);
if (!result) {
throw query_builder_exception(query_build_error::QueryError, result.release_error());
include/matador/query/builder.hpp
+63
View File
@@ -0,0 +1,63 @@
#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
include/matador/sql/column.hpp → include/matador/query/column.hpp
+11 -17
View File
@@ -1,28 +1,21 @@
#ifndef QUERY_COLUMN_HPP
#define QUERY_COLUMN_HPP
#include "matador/sql/sql_functions.hpp"
#include <functional>
#include <memory>
#include <string>
namespace matador::sql {
namespace matador::query {
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)
explicit column(std::string name, std::string as = "");
column(sql_function_t func, std::string name); // NOLINT(*-explicit-constructor)
column(std::string name, std::string as = "");
column(sql::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 = "");
@@ -34,17 +27,18 @@ public:
[[nodiscard]] std::string full_name() const;
[[nodiscard]] const std::string& alias_name() const;
[[nodiscard]] bool is_function() const;
[[nodiscard]] sql_function_t function() const;
[[nodiscard]] sql::sql_function_t function() const;
[[nodiscard]] bool has_alias() const;
[[nodiscard]] std::string alias() const;
[[nodiscard]] std::shared_ptr<sql::table> table() const;
void table(const std::shared_ptr<sql::table>& t);
[[nodiscard]] std::shared_ptr<table> table() const;
void table(const std::shared_ptr<query::table>& t);
private:
std::shared_ptr<sql::table> table_;
std::shared_ptr<query::table> table_;
std::string name;
std::string alias_;
sql_function_t function_{sql_function_t::None};
sql::sql_function_t function_{sql::sql_function_t::None};
};
column operator ""_col(const char *name, size_t len);
include/matador/query/criteria/abstract_column_criteria.hpp
+4 -4
View File
@@ -3,19 +3,19 @@
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/sql/column.hpp"
#include "matador/query/column.hpp"
namespace matador::query {
class abstract_column_criteria : public abstract_criteria {
public:
abstract_column_criteria() = delete;
explicit abstract_column_criteria(sql::column column);
explicit abstract_column_criteria(column col);
[[nodiscard]] const sql::column& column() const;
[[nodiscard]] const column& col() const;
protected:
sql::column column_;
column column_;
};
}
include/matador/query/criteria/between_criteria.hpp
+2 -2
View File
@@ -11,8 +11,8 @@ namespace matador::query {
class between_criteria final : public abstract_column_criteria {
public:
between_criteria() = delete;
between_criteria(sql::column column, int64_t min, int64_t max);
between_criteria(sql::column column, utils::placeholder min, utils::placeholder max);
between_criteria(column col, int64_t min, int64_t max);
between_criteria(column col, utils::placeholder min, utils::placeholder max);
void accept(criteria_visitor& visitor) const override;
include/matador/query/criteria/binary_criteria.hpp
+7 -7
View File
@@ -4,7 +4,7 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/query/criteria/criteria_utils.hpp"
#include "matador/sql/column.hpp"
#include "matador/query/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(sql::column column, binary_operator operand, criteria_value value);
binary_criteria(column col, 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(sql::column left_column, binary_operator operand, sql::column right_column);
binary_column_criteria(column left_column, binary_operator operand, column right_column);
void accept(criteria_visitor& visitor) const override;
[[nodiscard]] const sql::column& left_column() const;
[[nodiscard]] const column& left_column() const;
[[nodiscard]] binary_operator operand() const;
[[nodiscard]] const sql::column& right_column() const;
[[nodiscard]] const column& right_column() const;
private:
sql::column left_column_;
column left_column_;
binary_operator operator_{};
sql::column right_column_;
column right_column_;
};
}
#endif //CRITERIA_BINARY_CRITERIA_NODE_HPP
include/matador/query/criteria/collection_criteria.hpp
+4 -4
View File
@@ -4,7 +4,7 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/query/criteria/criteria_utils.hpp"
#include "matador/sql/column.hpp"
#include "matador/query/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(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);
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);
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(sql::column col, collection_operator operand_, sql::query_context ctx);
collection_query_criteria(column col, collection_operator operand_, sql::query_context ctx);
void accept(criteria_visitor& visitor) const override;
include/matador/query/criteria/criteria_operators.hpp
+28 -28
View File
@@ -4,7 +4,7 @@
#include "matador/query/criteria/binary_criteria.hpp"
#include "matador/query/criteria/collection_criteria.hpp"
#include "matador/sql/column.hpp"
#include "matador/query/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 sql::column &col, Type val) {
criteria_ptr operator==(const column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, utils::value(val));
}
template<class Type>
criteria_ptr operator!=(const sql::column &col, Type val) {
criteria_ptr operator!=(const 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 sql::column &col, Type val) {
criteria_ptr operator>(const 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 sql::column &col, Type val) {
criteria_ptr operator>=(const 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 sql::column &col, Type val) {
criteria_ptr operator<(const 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 sql::column &col, Type val) {
criteria_ptr operator<=(const column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, utils::value(val));
}
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_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, 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 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&&(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 sql::column &col, std::initializer_list<Type> args) {
criteria_ptr in(const 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 sql::column &col, std::initializer_list<Type> args) {
}
template <>
criteria_ptr in(const sql::column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr in(const column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr in(const sql::column &col, sql::query_context &&ctx);
criteria_ptr in(const column &col, sql::query_context &&ctx);
template < class Type >
criteria_ptr out(const sql::column &col, std::initializer_list<Type> args) {
criteria_ptr out(const 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 sql::column &col, std::initializer_list<Type> args) {
}
template <>
criteria_ptr out(const sql::column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr out(const column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr out(const sql::column &col, sql::query_context &&ctx);
criteria_ptr out(const column &col, sql::query_context &&ctx);
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 between(const column &col, int64_t min, int64_t max);
criteria_ptr between(const column &col, utils::placeholder min, utils::placeholder max);
criteria_ptr like(const sql::column &col, const std::string &pattern);
criteria_ptr like(const column &col, const std::string &pattern);
}
#endif //CRITERIA_CRITERIA_OPERATORS_HPP
include/matador/query/criteria/like_criteria.hpp
+2 -2
View File
@@ -3,13 +3,13 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
#include "matador/sql/column.hpp"
#include "matador/query/column.hpp"
namespace matador::query {
class like_criteria final : public abstract_column_criteria {
public:
like_criteria() = delete;
like_criteria(sql::column column, std::string pattern);
like_criteria(column col, std::string pattern);
void accept(criteria_visitor &visitor) const override;
include/matador/query/generator.hpp
+21 -21
View File
@@ -11,7 +11,7 @@
#include "matador/query/fk_value_extractor.hpp"
#include "matador/query/internal/column_value_pair.hpp"
#include "matador/sql/table.hpp"
#include "matador/query/table.hpp"
#include <vector>
@@ -53,13 +53,13 @@ public:
column_generator_options options = default_column_generator_options);
template< class Type >
std::vector<sql::column> generate() {
std::vector<column> generate() {
Type obj;
return generate(obj);
}
template< class Type >
std::vector<sql::column> generate(const Type &obj) {
std::vector<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<sql::table>(info.value().get().name()));
table_stack_.push(std::make_shared<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<sql::table>(info.value().get().name()));
table_stack_.push(std::make_shared<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<sql::column> result_;
std::stack<std::shared_ptr<sql::table>> table_stack_;
std::vector<column> result_;
std::stack<std::shared_ptr<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<sql::column> columns(const object::repository &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
std::vector<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<sql::column> columns(const object::repository &repo,
const column_generator_options options) {
std::vector<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<sql::column> columns(const object::repository &repo,
}
template<typename Type>
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) {
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) {
column_generator generator(repo, table_name, options);
return generator.generate(obj);
}
template<typename Type>
std::vector<sql::column> columns(const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
std::vector<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<sql::column> columns(const Type &obj,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
std::vector<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);
}
include/matador/query/intermediates/query_alter_intermediate.hpp
+1 -1
View File
@@ -9,7 +9,7 @@ class query_alter_intermediate : public query_intermediate {
public:
query_alter_intermediate();
query_alter_table_intermediate table(const sql::table &table) const;
query_alter_table_intermediate table(const table &tab) const;
};
}
include/matador/query/intermediates/query_alter_table_intermediate.hpp
+7 -7
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 sql::table& table, const std::vector<sql::column>& columns = {});
executable_query references(const table& tab, const std::vector<column>& columns = {});
private:
sql::table table_;
std::vector<sql::column> columns_;
table table_;
std::vector<column> columns_;
};
class query_add_key_constraint_intermediate final : public query_intermediate {
public:
using query_intermediate::query_intermediate;
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;
[[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;
};
class query_alter_table_intermediate final : public query_intermediate {
include/matador/query/intermediates/query_create_intermediate.hpp
+4 -4
View File
@@ -13,11 +13,11 @@ class query_create_intermediate : public query_intermediate {
public:
query_create_intermediate();
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);
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);
template<class Type>
executable_query table(const sql::table &table, const object::repository &schema) {
return this->table(table, object::attribute_definition_generator::generate<Type>(schema));
executable_query table(const query::table &tab, const object::repository &schema) {
return this->table(tab, object::attribute_definition_generator::generate<Type>(schema));
}
executable_query schema(const std::string &schema_name);
};
include/matador/query/intermediates/query_delete_intermediate.hpp
+1 -1
View File
@@ -12,7 +12,7 @@ class query_delete_intermediate : public query_intermediate
public:
query_delete_intermediate();
query_delete_from_intermediate from(const sql::table &table);
query_delete_from_intermediate from(const table &tab);
};
}
include/matador/query/intermediates/query_drop_intermediate.hpp
+1 -1
View File
@@ -9,7 +9,7 @@ class query_drop_intermediate : query_intermediate {
public:
query_drop_intermediate();
executable_query table(const sql::table &table);
executable_query table(const table &tab);
executable_query schema(const std::string &schema_name);
};
include/matador/query/intermediates/query_execute_where_intermediate.hpp
+1 -1
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 sql::column &col);
query_execute_order_by_intermediate order_by(const column &col);
};
}
include/matador/query/intermediates/query_from_intermediate.hpp
+3 -3
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 sql::table &t);
query_join_intermediate join_left(const 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 sql::column &col);
query_order_by_intermediate order_by(const sql::column &col);
query_group_by_intermediate group_by(const column &col);
query_order_by_intermediate order_by(const column &col);
private:
query_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);
include/matador/query/intermediates/query_group_by_intermediate.hpp
+1 -1
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 sql::column &col);
query_order_by_intermediate order_by(const column &col);
};
}
include/matador/query/intermediates/query_insert_intermediate.hpp
+6 -6
View File
@@ -14,13 +14,13 @@ public:
query_insert_intermediate();
template<class Type>
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, const object::repository &schema) {
return into(tab, generator::columns<Type>(schema));
}
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);
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);
};
}
include/matador/query/intermediates/query_select_intermediate.hpp
+2 -2
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<sql::column>& columns);
explicit query_select_intermediate(const std::vector<column>& columns);
query_from_intermediate from(const sql::table& t);
query_from_intermediate from(const table& t);
};
}
include/matador/query/intermediates/query_update_intermediate.hpp
+1 -1
View File
@@ -13,7 +13,7 @@ namespace matador::query {
class query_update_intermediate : public query_intermediate {
public:
explicit query_update_intermediate(const sql::table& table);
explicit query_update_intermediate(const table& tab);
query_set_intermediate set(std::initializer_list<internal::column_value_pair> columns);
query_set_intermediate set(std::vector<internal::column_value_pair> &&columns);
include/matador/query/intermediates/query_where_intermediate.hpp
+2 -2
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 sql::column &col);
query_order_by_intermediate order_by(const sql::column &col);
query_group_by_intermediate group_by(const column &col);
query_order_by_intermediate order_by(const column &col);
};
}
include/matador/query/internal/column_value_pair.hpp
+4 -4
View File
@@ -1,7 +1,7 @@
#ifndef QUERY_KEY_VALUE_PAIR_HPP
#define QUERY_KEY_VALUE_PAIR_HPP
#include "matador/sql/column.hpp"
#include "matador/query/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 sql::column &col, utils::database_type value);
column_value_pair(const 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 sql::column& col() const;
[[nodiscard]] const column& col() const;
[[nodiscard]] const std::variant<utils::placeholder, utils::database_type>& value() const;
private:
sql::column column_;
column column_;
std::variant<utils::placeholder, utils::database_type> value_;
};
include/matador/query/internal/query_parts.hpp
+50 -50
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(sql::table table);
explicit query_alter_table_part(table tab);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const table& table() const;
private:
sql::table table_;
query::table table_;
};
class query_add_key_constraint_part final : public query_part {
public:
explicit query_add_key_constraint_part(const std::string& name);
explicit query_add_key_constraint_part(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(const std::string& name);
explicit query_drop_key_constraint_part(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<sql::column>& columns);
explicit query_add_foreign_key_constraint_part( const std::vector<column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<sql::column>& columns() const;
[[nodiscard]] const std::vector<column>& columns() const;
private:
std::vector<sql::column> columns_;
std::vector<column> columns_;
};
class query_add_foreign_key_reference_part final : public query_part {
public:
explicit query_add_foreign_key_reference_part(sql::table table, const std::vector<sql::column>& columns);
explicit query_add_foreign_key_reference_part(table tab, const std::vector<column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const std::vector<sql::column>& columns() const;
[[nodiscard]] const table& table() const;
[[nodiscard]] const std::vector<column>& columns() const;
private:
sql::table table_;
std::vector<sql::column> columns_;
query::table table_;
std::vector<column> columns_;
};
class query_add_primary_key_constraint_part final : public query_part {
public:
explicit query_add_primary_key_constraint_part( const std::vector<sql::column>& columns);
explicit query_add_primary_key_constraint_part( const std::vector<column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<sql::column>& columns() const;
[[nodiscard]] const std::vector<column>& columns() const;
private:
std::vector<sql::column> columns_;
std::vector<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<sql::column> columns);
explicit query_select_part(std::vector<column> columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<sql::column>& columns() const;
[[nodiscard]] const std::vector<column>& columns() const;
private:
std::vector<sql::column> columns_;
std::vector<column> columns_;
};
/**
@@ -116,29 +116,29 @@ private:
class query_from_part final : public query_part
{
public:
explicit query_from_part(sql::table t);
explicit query_from_part(table t);
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::table table_;
class table table_;
};
class query_join_part final : public query_part
{
public:
explicit query_join_part(sql::table t);
explicit query_join_part(table t);
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::table table_;
class 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(sql::column col);
explicit query_group_by_part(column col);
[[nodiscard]] const sql::column& column() const;
[[nodiscard]] const column& column() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::column column_;
class column column_;
};
class query_order_by_part final : public query_part
{
public:
explicit query_order_by_part(sql::column col);
explicit query_order_by_part(column col);
[[nodiscard]] const sql::column& column() const;
[[nodiscard]] const column& column() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::column column_;
class 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(sql::table t, std::vector<sql::column> columns);
query_into_part(table t, std::vector<column> columns);
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const std::vector<sql::column>& columns() const;
[[nodiscard]] const table& table() const;
[[nodiscard]] const std::vector<column>& columns() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::table table_;
std::vector<sql::column> columns_;
class table table_;
std::vector<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(sql::table table);
explicit query_update_part(table table);
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::table table_;
class 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(sql::table table);
explicit query_delete_from_part(table table);
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::table table_;
class 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(sql::table table, std::vector<object::attribute_definition> columns);
query_create_table_part(table table, std::vector<object::attribute_definition> columns);
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const table& table() const;
[[nodiscard]] const std::vector<object::attribute_definition>& columns() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::table table_;
class 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(sql::table table);
explicit query_drop_table_part(table table);
[[nodiscard]] const sql::table& table() const;
[[nodiscard]] const table& table() const;
private:
void accept(query_part_visitor &visitor) override;
private:
sql::table table_;
class table table_;
};
class query_drop_schema_part final : public query_part {
include/matador/query/join_data.hpp
+2 -2
View File
@@ -3,14 +3,14 @@
#include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/sql/table.hpp"
#include "matador/query/table.hpp"
#include <memory>
namespace matador::query {
struct join_data {
std::shared_ptr<sql::table> join_table;
std::shared_ptr<table> join_table;
std::unique_ptr<abstract_criteria> condition;
};
include/matador/query/query.hpp
+8 -8
View File
@@ -10,10 +10,10 @@ class connection;
}
namespace matador::query {
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();
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();
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<sql::column> columns);
[[nodiscard]] static query_select_intermediate select(const std::vector<sql::column>& columns);
[[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(const std::vector<std::string> &column_names);
[[nodiscard]] static query_select_intermediate select(std::vector<sql::column> columns, std::initializer_list<sql::column> additional_columns);
[[nodiscard]] static query_select_intermediate select(std::vector<column> columns, std::initializer_list<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 sql::table &table);
[[nodiscard]] static query_update_intermediate update(const table &table);
[[nodiscard]] static query_delete_intermediate remove();
[[nodiscard]] static query_alter_intermediate alter();
include/matador/query/query_compiler.hpp
+1 -2
View File
@@ -68,8 +68,7 @@ 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 sql::table& t);
static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const table& t);
static std::string determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val);
protected:
include/matador/query/query_data.hpp
+2 -3
View File
@@ -6,8 +6,7 @@
#include "matador/object/attribute_definition.hpp"
#include "matador/sql/table.hpp"
#include "matador/query/table.hpp"
#include "matador/query/query_part.hpp"
namespace matador::query {
@@ -15,7 +14,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, sql::table> tables{};
std::unordered_map<std::string, table> tables{};
};
}
include/matador/query/query_utils.hpp
+17
View File
@@ -0,0 +1,17 @@
#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
include/matador/sql/table.hpp → include/matador/query/table.hpp
+2 -2
View File
@@ -1,12 +1,12 @@
#ifndef QUERY_TABLE_HPP
#define QUERY_TABLE_HPP
#include "matador/sql/column.hpp"
#include "column.hpp"
#include <string>
#include <vector>
namespace matador::sql {
namespace matador::query {
class column;
include/matador/sql/dialect.hpp
+2 -3
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,6 +42,7 @@ 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
@@ -51,9 +52,7 @@ 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;
include/matador/sql/interface/connection_impl.hpp
+2
View File
@@ -4,8 +4,10 @@
#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"
include/matador/sql/query_context.hpp
+2 -2
View File
@@ -2,7 +2,7 @@
#define QUERY_QUERY_DATA_HPP
#include "matador/object/attribute_definition.hpp"
#include "matador/sql/table.hpp"
#include "matador/query/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{};
sql::table table{""};
std::string table_name{};
std::vector<object::attribute_definition> prototype{};
std::vector<std::string> result_vars{};
std::vector<std::string> bind_vars{};
include/matador/sql/query_macro.hpp
+2 -2
View File
@@ -3,8 +3,8 @@
#include "matador/utils/macro_map.hpp"
#include "matador/sql/table.hpp"
#include "matador/sql/column.hpp"
#include "matador/query/table.hpp"
#include "matador/query/column.hpp"
#include <string>
#include <ostream>
include/matador/sql/record.hpp
+3 -5
View File
@@ -8,8 +8,6 @@
namespace matador::sql {
class column;
class record final {
private:
using field_ref = std::reference_wrapper<field>;
@@ -41,11 +39,11 @@ public:
[[nodiscard]] const std::vector<field_ref>& columns() const;
[[nodiscard]] const field& at(const sql::column &col) const;
[[nodiscard]] const field& at(const std::string &name) const;
[[nodiscard]] const field& at(size_t index) const;
template<class Type>
std::optional<Type> at(const column &col) const {
return at(col).as<Type>();
std::optional<Type> at(const std::string &name) const {
return at(name).as<Type>();
}
template<class Type>
std::optional<Type> at(const size_t index) const {
include/matador/sql/sql_functions.hpp
+14
View File
@@ -0,0 +1,14 @@
#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