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

renamed column to table_column and constraint to table_constraint.

Browse Source
This commit is contained in:
sascha
2025-12-31 13:01:54 +01:00
parent ab2d39407c
commit b9d35cbd4e
62 changed files with 424 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/matador/orm/session.hpp
+24 -29
View File
@@ -7,6 +7,7 @@
#include "matador/query/criteria.hpp"
#include "matador/query/query.hpp"
#include "matador/query/generator.hpp"
#include "matador/query/schema.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/connection_pool.hpp"
@@ -15,7 +16,6 @@
#include "matador/sql/statement_cache.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/object/repository.hpp"
#include <unordered_map>
@@ -71,20 +71,13 @@ public:
}
template<class Pointer>
void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {
}
void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many(const char * /*id*/, ContainerType &, const char *join_column, const utils::foreign_attributes &attr) {
}
void on_has_many(const char * /*id*/, ContainerType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &/*cont*/, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr) {
}
void on_has_many_to_many(const char * /*id*/, ContainerType &/*cont*/, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &/*cont*/, const utils::foreign_attributes &attr) {
}
void on_has_many_to_many(const char * /*id*/, ContainerType &/*cont*/, const utils::foreign_attributes &/*attr*/) {}
private:
const std::unordered_map<std::string, sql::statement> &statements_per_column_;
@@ -151,7 +144,7 @@ private:
mutable sql::statement_cache cache_;
const sql::dialect &dialect_;
std::unique_ptr<object::repository> schema_;
std::unique_ptr<query::schema> schema_;
mutable std::unordered_map<std::string, std::vector<object::attribute>> prototypes_;
};
@@ -167,7 +160,7 @@ utils::result<void, utils::error> session::attach( const std::string& table_name
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::insert(Type *obj) {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (!info) {
return utils::failure(info.err());
}
@@ -240,14 +233,14 @@ private:
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::update( const object::object_ptr<Type>& obj ) {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (!info) {
return utils::failure(info.err());
}
using namespace matador::utils;
using namespace matador::query;
const auto col = column(info.value().get().primary_key_attribute()->name());
const auto col = table_column(info.value().get().primary_key_attribute()->name());
auto res = matador::query::query::update(info->get().name())
.set(generator::column_value_pairs<Type>())
.where(col == _)
@@ -266,14 +259,14 @@ utils::result<object::object_ptr<Type>, utils::error> session::update( const obj
template<typename Type>
utils::result<void, utils::error> session::remove( const object::object_ptr<Type>& obj ) {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (!info) {
return utils::failure(info.err());
}
using namespace matador::utils;
using namespace matador::query;
const auto col = column(info.value().get().primary_key_attribute()->name());
const auto col = table_column(info.value().get().primary_key_attribute()->name());
auto res = matador::query::query::remove()
.from( info->get().name() )
.where(col == _)
@@ -291,22 +284,24 @@ utils::result<void, utils::error> session::remove( const object::object_ptr<Type
template<typename Type, typename PrimaryKeyType>
utils::result<object::object_ptr<Type>, utils::error> session::find(const PrimaryKeyType& pk) {
auto info = schema_->info<Type>();
if (!info) {
const auto it = schema_->find(typeid(Type));
if (it == schema_->end()) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
}
if (!info.value().get().has_primary_key()) {
const auto& info = it->second.node().info();
// if (!info) {
// return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
// }
if (!info.has_primary_key()) {
return utils::failure(make_error(error_code::NoPrimaryKey, "Type hasn't primary key."));
}
const auto& type_info = info.value().get();
session_query_builder eqb(*schema_, *this);
const query::column col(std::make_shared<query::table>(type_info.name()), type_info.primary_key_attribute()->name());
const query::table_column c(&it->second.table(),info.primary_key_attribute()->name());
using namespace matador::query;
auto data = eqb.build<Type>(col == utils::_);
auto data = eqb.build<Type>(c == utils::_);
if (!data.is_ok()) {
return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + type_info.name() + "."));
return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info.name() + "."));
}
auto res = build_select_query(data.release()).prepare(*this);
@@ -316,14 +311,14 @@ utils::result<object::object_ptr<Type>, utils::error> session::find(const Primar
}
auto stmt_result = res->bind(0, const_cast<PrimaryKeyType&>(pk)).template fetch_one<Type>();
if (stmt_result && !stmt_result.value()) {
return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + type_info.name() + " with primary key " + std::to_string(pk) + "."));
return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + info.name() + " with primary key " + std::to_string(pk) + "."));
}
return utils::ok(object::object_ptr<Type>{ stmt_result->release() });
}
template<typename Type>
utils::result<sql::query_result<Type>, utils::error> session::find(query::criteria_ptr clause) {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (!info) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
}
@@ -344,7 +339,7 @@ utils::result<sql::query_result<Type>, utils::error> session::find(query::criter
template<typename Type>
utils::result<void, utils::error> session::drop_table() {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (info) {
return drop_table(info->get().name());
}
include/matador/orm/session_query_builder.hpp
+15 -15
View File
@@ -26,7 +26,7 @@ namespace matador::orm {
struct entity_query_data {
const query::table* root_table{nullptr};
std::string pk_column_name{};
std::vector<query::column> columns{};
std::vector<query::table_column> columns{};
std::unordered_map<std::string, sql::statement> lazy_loading_statements{};
std::vector<query::join_data> joins{};
query::criteria_ptr where_clause{};
@@ -144,8 +144,8 @@ public:
}
append_join(
query::column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()},
query::column{&next->second, join_column}
query::table_column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()},
query::table_column{&next->second, join_column}
);
@@ -210,12 +210,12 @@ public:
}
append_join(
query::column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()},
query::column{&relation->second, join_column}
query::table_column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()},
query::table_column{&relation->second, join_column}
);
append_join(
query::column{&relation->second, inverse_join_column},
query::column{&next->second, result->second.node().info().primary_key_attribute()->name()}
query::table_column{&relation->second, inverse_join_column},
query::table_column{&next->second, result->second.node().info().primary_key_attribute()->name()}
);
}
@@ -257,12 +257,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.primary_key_attribute()->name()},
query::column{&relation->second, join_columns.inverse_join_column}
query::table_column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()},
query::table_column{&relation->second, join_columns.inverse_join_column}
);
append_join(
query::column{&relation->second, join_columns.join_column},
query::column{&next->second, result->second.node().info().primary_key_attribute()->name()}
query::table_column{&relation->second, join_columns.join_column},
query::table_column{&next->second, result->second.node().info().primary_key_attribute()->name()}
);
}
@@ -272,7 +272,7 @@ 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 query::table_column &left, const query::table_column &right);
private:
struct table_info {
@@ -317,8 +317,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, info.primary_key_attribute()->name()}
query::table_column{&table_info_stack_.top().table, id},
query::table_column{&next->second, info.primary_key_attribute()->name()}
);
} else {
push(id);
@@ -327,7 +327,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, info.primary_key_attribute()->name(), "") == _)
.where(table_column(&foreign_table, info.primary_key_attribute()->name(), "") == _)
.prepare(executor_);
if (!result) {
throw query_builder_exception(query_build_error::QueryError, result.release_error());
include/matador/query/builder.hpp
+4 -4
View File
@@ -1,8 +1,8 @@
#ifndef MATADOR_BUILDER_HPP
#define MATADOR_BUILDER_HPP
#include "matador/query/column.hpp"
#include "matador/query/constraint.hpp"
#include "matador/query/table_column.hpp"
#include "matador/query/table_constraint.hpp"
#include "matador/query/table.hpp"
#include "matador/utils/basic_types.hpp"
@@ -65,7 +65,7 @@ public:
explicit column_builder(std::string column_name, utils::basic_type type, size_t size = 0);
// ReSharper disable once CppNonExplicitConversionOperator
operator column() const; // NOLINT(*-explicit-constructor)
operator table_column() const; // NOLINT(*-explicit-constructor)
column_builder& not_null();
column_builder& primary_key();
@@ -97,7 +97,7 @@ public:
constraint_builder& references(std::string table, std::string column);
// ReSharper disable once CppNonExplicitConversionOperator
operator class constraint() const; // NOLINT(*-explicit-constructor)
operator table_constraint() const; // NOLINT(*-explicit-constructor)
private:
std::string constraint_name_;
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/query/column.hpp"
#include "matador/query/table_column.hpp"
namespace matador::query {
class abstract_column_criteria : public abstract_criteria {
public:
abstract_column_criteria() = delete;
explicit abstract_column_criteria(const class column& col);
explicit abstract_column_criteria(const table_column& col);
[[nodiscard]] const class column& col() const;
[[nodiscard]] const table_column& col() const;
protected:
class column column_;
table_column column_;
};
}
include/matador/query/criteria/between_criteria.hpp
+2 -2
View File
@@ -9,8 +9,8 @@ namespace matador::query {
class between_criteria final : public abstract_column_criteria {
public:
between_criteria() = delete;
between_criteria(const class column& col, int64_t min, int64_t max);
between_criteria(const class column& col, utils::placeholder min, utils::placeholder max);
between_criteria(const table_column& col, int64_t min, int64_t max);
between_criteria(const table_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/query/column.hpp"
#include "matador/query/table_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(const class column& col, binary_operator operand, criteria_value value);
binary_criteria(const table_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(const class column& left_column, binary_operator operand, const class column& right_column);
binary_column_criteria(const table_column& left_column, binary_operator operand, const table_column& right_column);
void accept(criteria_visitor& visitor) const override;
[[nodiscard]] const class column& left_column() const;
[[nodiscard]] const table_column& left_column() const;
[[nodiscard]] binary_operator operand() const;
[[nodiscard]] const class column& right_column() const;
[[nodiscard]] const table_column& right_column() const;
private:
class column left_column_;
table_column left_column_;
binary_operator operator_{};
class column right_column_;
table_column right_column_;
};
}
#endif //CRITERIA_BINARY_CRITERIA_NODE_HPP
include/matador/query/criteria/collection_criteria.hpp
+4 -4
View File
@@ -8,7 +8,7 @@
#include "matador/sql/query_context.hpp"
namespace matador::query {
class column;
class table_column;
enum class collection_operator {
In,
@@ -38,8 +38,8 @@ public:
* @param operand_ Operator to use
* @param values List of values
*/
collection_criteria(const class column& col, collection_operator operand_, std::vector<criteria_value> values);
collection_criteria(const class column& col, collection_operator operand_, std::initializer_list<criteria_value> values);
collection_criteria(const table_column& col, collection_operator operand_, std::vector<criteria_value> values);
collection_criteria(const table_column& col, collection_operator operand_, std::initializer_list<criteria_value> values);
void accept(criteria_visitor& visitor) const override;
@@ -54,7 +54,7 @@ private:
class collection_query_criteria final : public abstract_column_criteria {
public:
collection_query_criteria() = delete;
collection_query_criteria(const class column& col, collection_operator operand_, sql::query_context ctx);
collection_query_criteria(const table_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
@@ -11,51 +11,51 @@ namespace matador::sql {
struct query_context;
}
namespace matador::query {
class column;
class table_column;
template<class Type>
criteria_ptr operator==(const class column &col, Type val) {
criteria_ptr operator==(const table_column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, utils::value(val));
}
template<class Type>
criteria_ptr operator!=(const class column &col, Type val) {
criteria_ptr operator!=(const table_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 class column &col, Type val) {
criteria_ptr operator>(const table_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 class column &col, Type val) {
criteria_ptr operator>=(const table_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 class column &col, Type val) {
criteria_ptr operator<(const table_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 class column &col, Type val) {
criteria_ptr operator<=(const table_column &col, Type val) {
return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN_OR_EQUAL, utils::value(val));
}
criteria_ptr operator==(const class column &col_left, const class column &col_right);
criteria_ptr operator!=(const class column &col_left, const class column &col_right);
criteria_ptr operator>(const class column &col_left, const class column &col_right);
criteria_ptr operator>=(const class column &col_left, const class column &col_right);
criteria_ptr operator<(const class column &col_left, const class column &col_right);
criteria_ptr operator<=(const class column &col_left, const class column &col_right);
criteria_ptr operator==(const table_column &col_left, const table_column &col_right);
criteria_ptr operator!=(const table_column &col_left, const table_column &col_right);
criteria_ptr operator>(const table_column &col_left, const table_column &col_right);
criteria_ptr operator>=(const table_column &col_left, const table_column &col_right);
criteria_ptr operator<(const table_column &col_left, const table_column &col_right);
criteria_ptr operator<=(const table_column &col_left, const table_column &col_right);
criteria_ptr operator==(const class column &col, utils::placeholder p);
criteria_ptr operator!=(const class column &col, utils::placeholder p);
criteria_ptr operator>(const class column &col, utils::placeholder p);
criteria_ptr operator>=(const class column &col, utils::placeholder p);
criteria_ptr operator<(const class column &col, utils::placeholder p);
criteria_ptr operator<=(const class column &col, utils::placeholder p);
criteria_ptr operator==(const table_column &col, utils::placeholder p);
criteria_ptr operator!=(const table_column &col, utils::placeholder p);
criteria_ptr operator>(const table_column &col, utils::placeholder p);
criteria_ptr operator>=(const table_column &col, utils::placeholder p);
criteria_ptr operator<(const table_column &col, utils::placeholder p);
criteria_ptr operator<=(const table_column &col, utils::placeholder p);
criteria_ptr operator&&(criteria_ptr left, criteria_ptr right);
@@ -64,7 +64,7 @@ criteria_ptr operator||(criteria_ptr left, criteria_ptr right);
criteria_ptr operator!(criteria_ptr clause);
template < class Type >
criteria_ptr in(const class column &col, std::initializer_list<Type> args) {
criteria_ptr in(const table_column &col, std::initializer_list<Type> args) {
std::vector<criteria_value> values;
for ( auto &&arg : args ) {
values.emplace_back(utils::value{std::move(arg)});
@@ -73,12 +73,12 @@ criteria_ptr in(const class column &col, std::initializer_list<Type> args) {
}
template <>
criteria_ptr in(const class column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr in(const table_column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr in(const class column &col, sql::query_context &&ctx);
criteria_ptr in(const table_column &col, sql::query_context &&ctx);
template < class Type >
criteria_ptr out(const class column &col, std::initializer_list<Type> args) {
criteria_ptr out(const table_column &col, std::initializer_list<Type> args) {
std::vector<criteria_value> values;
for ( auto &&arg : args ) {
values.emplace_back(utils::value{std::move(arg)});
@@ -87,14 +87,14 @@ criteria_ptr out(const class column &col, std::initializer_list<Type> args) {
}
template <>
criteria_ptr out(const class column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr out(const table_column &col, std::initializer_list<utils::placeholder> args);
criteria_ptr out(const class column &col, sql::query_context &&ctx);
criteria_ptr out(const table_column &col, sql::query_context &&ctx);
criteria_ptr between(const class column &col, int64_t min, int64_t max);
criteria_ptr between(const class column &col, utils::placeholder min, utils::placeholder max);
criteria_ptr between(const table_column &col, int64_t min, int64_t max);
criteria_ptr between(const table_column &col, utils::placeholder min, utils::placeholder max);
criteria_ptr like(const class column &col, const std::string &pattern);
criteria_ptr like(const table_column &col, const std::string &pattern);
}
#endif //CRITERIA_CRITERIA_OPERATORS_HPP
include/matador/query/criteria/like_criteria.hpp
+2 -2
View File
@@ -4,12 +4,12 @@
#include "matador/query/criteria/abstract_column_criteria.hpp"
namespace matador::query {
class column;
class table_column;
class like_criteria final : public abstract_column_criteria {
public:
like_criteria() = delete;
like_criteria(const class column& col, std::string pattern);
like_criteria(const table_column& col, std::string pattern);
void accept(criteria_visitor &visitor) const override;
include/matador/query/generator.hpp
+6 -6
View File
@@ -50,13 +50,13 @@ public:
column_generator_options options = default_column_generator_options);
template< class Type >
std::vector<column> generate() {
std::vector<table_column> generate() {
Type obj;
return generate(obj);
}
template< class Type >
std::vector<column> generate(const Type &obj) {
std::vector<table_column> generate(const Type &obj) {
result_.clear();
access::process(*this, obj);
@@ -146,7 +146,7 @@ private:
private:
std::optional<std::reference_wrapper<const schema>> repo_;
std::vector<column> result_;
std::vector<table_column> result_;
std::stack<std::shared_ptr<table>> table_stack_;
std::unordered_set<std::string> seen_tables;
int column_index{0};
@@ -293,7 +293,7 @@ std::vector<internal::column_value_pair> column_value_pairs() {
}
template<typename Type>
std::vector<column> columns(const schema &repo,
std::vector<table_column> columns(const schema &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
column_generator generator(repo, table_name, options);
@@ -301,7 +301,7 @@ std::vector<column> columns(const schema &repo,
}
template<typename Type>
std::vector<column> columns(const schema &repo,
std::vector<table_column> columns(const schema &repo,
const column_generator_options options) {
std::string table_name;
if (const auto result = repo.repo().info<Type>()) {
@@ -312,7 +312,7 @@ std::vector<column> columns(const schema &repo,
}
template<typename Type>
std::vector<column> columns(const Type &obj,
std::vector<table_column> columns(const Type &obj,
const schema &repo,
const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) {
include/matador/query/intermediates/query_alter_table_intermediate.hpp
+7 -7
View File
@@ -3,7 +3,7 @@
#include "matador/query/intermediates/executable_query.hpp"
#include "matador/query/intermediates/query_intermediate.hpp"
#include "matador/query/constraint.hpp"
#include "matador/query/table_constraint.hpp"
#include "matador/object/restriction.hpp"
@@ -16,21 +16,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 table& tab, const std::vector<table_column>& columns = {});
private:
table table_;
std::vector<column> columns_;
std::vector<table_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;
[[nodiscard]] query_add_primary_key_constraint_intermediate primary_key(const table_column& col) const;
[[nodiscard]] query_add_primary_key_constraint_intermediate primary_keys(const std::vector<table_column>& columns) const;
[[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_key(const table_column& col) const;
[[nodiscard]] query_add_foreign_key_constraint_intermediate foreign_keys(const std::vector<table_column>& columns) const;
};
class query_alter_table_intermediate final : public query_intermediate {
include/matador/query/intermediates/query_create_intermediate.hpp
+5 -5
View File
@@ -5,7 +5,7 @@
#include "matador/query/intermediates/executable_query.hpp"
#include "matador/query/constraint.hpp"
#include "matador/query/table_constraint.hpp"
#include "matador/object/attribute.hpp"
#include "matador/object/restriction.hpp"
@@ -20,8 +20,8 @@ public:
executable_query constraints(std::initializer_list<object::restriction> constraints);
executable_query constraints(const std::list<object::restriction> &restrictions);
executable_query constraints(std::initializer_list<constraint> constraints);
executable_query constraints(const std::list<constraint> &restrictions);
executable_query constraints(std::initializer_list<table_constraint> constraints);
executable_query constraints(const std::list<table_constraint> &restrictions);
};
class query_create_table_intermediate : public query_intermediate {
@@ -30,8 +30,8 @@ public:
query_create_table_columns_intermediate columns(std::initializer_list<object::attribute> attributes);
query_create_table_columns_intermediate columns(const std::list<object::attribute> &attributes);
query_create_table_columns_intermediate columns(std::initializer_list<column> columns);
query_create_table_columns_intermediate columns(const std::list<column> &columns);
query_create_table_columns_intermediate columns(std::initializer_list<table_column> columns);
query_create_table_columns_intermediate columns(const std::list<table_column> &columns);
};
class query_create_intermediate : public query_intermediate {
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 column &col);
query_execute_order_by_intermediate order_by(const table_column &col);
};
}
include/matador/query/intermediates/query_from_intermediate.hpp
+2 -2
View File
@@ -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 table_column &col);
query_order_by_intermediate order_by(const table_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 column &col);
query_order_by_intermediate order_by(const table_column &col);
};
}
include/matador/query/intermediates/query_insert_intermediate.hpp
+2 -2
View File
@@ -16,8 +16,8 @@ public:
query_into_intermediate into(const table &tab, const schema &scm) {
return into(tab, generator::columns<Type>(scm));
}
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, std::initializer_list<table_column> columns);
query_into_intermediate into(const table &tab, std::vector<table_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
+1 -1
View File
@@ -10,7 +10,7 @@ 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<table_column>& columns);
query_from_intermediate from(const table& t);
};
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 column &col);
query_order_by_intermediate order_by(const column &col);
query_group_by_intermediate group_by(const table_column &col);
query_order_by_intermediate order_by(const table_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/query/column.hpp"
#include "matador/query/table_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 table_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 table_column& col() const;
[[nodiscard]] const std::variant<utils::placeholder, utils::database_type>& value() const;
private:
column column_;
table_column column_;
std::variant<utils::placeholder, utils::database_type> value_;
};
include/matador/query/internal/query_parts.hpp
+35 -35
View File
@@ -6,8 +6,8 @@
#include "matador/query/internal/column_value_pair.hpp"
#include "matador/query/query_part.hpp"
#include "matador/query/column.hpp"
#include "matador/query/constraint.hpp"
#include "matador/query/table_column.hpp"
#include "matador/query/table_constraint.hpp"
#include "matador/query/table.hpp"
#include "matador/utils/placeholder.hpp"
@@ -50,12 +50,12 @@ private:
class query_add_constraint_part_by_constraint final : public query_part {
public:
explicit query_add_constraint_part_by_constraint(const constraint& co);
explicit query_add_constraint_part_by_constraint(const table_constraint& co);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const class constraint& constraint() const;
[[nodiscard]] const table_constraint& constraint() const;
private:
class constraint constraint_;
table_constraint constraint_;
};
class query_drop_key_constraint_part_by_name final : public query_part {
@@ -70,45 +70,45 @@ private:
class query_drop_key_constraint_part_by_constraint final : public query_part {
public:
explicit query_drop_key_constraint_part_by_constraint(const constraint& co);
explicit query_drop_key_constraint_part_by_constraint(const table_constraint& co);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const class constraint& constraint() const;
[[nodiscard]] const table_constraint& constraint() const;
private:
class constraint constraint_;
table_constraint constraint_;
};
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<table_column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<table_column>& columns() const;
private:
std::vector<column> columns_;
std::vector<table_column> columns_;
};
class query_add_foreign_key_reference_part final : public query_part {
public:
explicit query_add_foreign_key_reference_part(class table tab, const std::vector<column>& columns);
explicit query_add_foreign_key_reference_part(class table tab, const std::vector<table_column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const class table& table() const;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<table_column>& columns() const;
private:
query::table table_;
std::vector<column> columns_;
std::vector<table_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<table_column>& columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<table_column>& columns() const;
private:
std::vector<column> columns_;
std::vector<table_column> columns_;
};
/**
@@ -117,13 +117,13 @@ private:
class query_select_part final : public query_part
{
public:
explicit query_select_part(std::vector<column> columns);
explicit query_select_part(std::vector<table_column> columns);
void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<table_column>& columns() const;
private:
std::vector<column> columns_;
std::vector<table_column> columns_;
};
/**
@@ -205,29 +205,29 @@ protected:
class query_group_by_part final : public query_part
{
public:
explicit query_group_by_part(class column col);
explicit query_group_by_part(class table_column col);
[[nodiscard]] const class column& column() const;
[[nodiscard]] const table_column& column() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class column column_;
table_column column_;
};
class query_order_by_part final : public query_part
{
public:
explicit query_order_by_part(class column col);
explicit query_order_by_part(class table_column col);
[[nodiscard]] const class column& column() const;
[[nodiscard]] const table_column& column() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class column column_;
table_column column_;
};
class query_order_by_asc_part final : public query_part
@@ -288,17 +288,17 @@ private:
class query_into_part final : public query_part
{
public:
query_into_part(class table tab, std::vector<column> columns);
query_into_part(class table tab, std::vector<table_column> columns);
[[nodiscard]] const class table& table() const;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<table_column>& columns() const;
private:
void accept(query_part_visitor &visitor) override;
private:
class table table_;
std::vector<column> columns_;
std::vector<table_column> columns_;
};
/**
* Represents the SQL VALUES part
@@ -393,28 +393,28 @@ private:
class query_create_table_columns_part final : public query_part {
public:
explicit query_create_table_columns_part(const std::list<column> &columns);
explicit query_create_table_columns_part(const std::list<table_column> &columns);
[[nodiscard]] const std::list<column>& columns() const;
[[nodiscard]] const std::list<table_column>& columns() const;
private:
void accept(query_part_visitor &visitor) override;
private:
std::list<column> columns_;
std::list<table_column> columns_;
};
class query_create_table_constraints_part final : public query_part {
public:
explicit query_create_table_constraints_part(const std::list<constraint> &constraints);
explicit query_create_table_constraints_part(const std::list<table_constraint> &constraints);
[[nodiscard]] const std::list<constraint>& constraints() const;
[[nodiscard]] const std::list<table_constraint>& constraints() const;
private:
void accept(query_part_visitor &visitor) override;
private:
std::list<constraint> constraints_;
std::list<table_constraint> constraints_;
};
class query_create_schema_part final : public query_part {
include/matador/query/query.hpp
+7 -7
View File
@@ -11,10 +11,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();
table_column alias(const std::string &column, const std::string &as);
table_column alias(table_column &&col, const std::string &as);
table_column count(const std::string &column);
table_column count_all();
class query
{
@@ -22,10 +22,10 @@ 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<table_column> columns);
[[nodiscard]] static query_select_intermediate select(const std::vector<table_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<table_column> columns, std::initializer_list<table_column> additional_columns);
template<class Type>
[[nodiscard]] static query_select_intermediate select(const schema &scm) {
return select(generator::columns<Type>(scm));
include/matador/query/query_compiler.hpp
+5 -3
View File
@@ -22,6 +22,8 @@ namespace internal {
struct basic_type_to_string_visitor;
}
class table_constraint;
struct query_data;
struct value_visitor;
@@ -77,9 +79,9 @@ protected:
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);
std::string build_add_constraint_string(const class constraint& c) const;
std::string build_drop_constraint_string(const class constraint& c) const;
static std::string build_constraint_name(const class constraint& c);
[[nodiscard]] std::string build_add_constraint_string(const table_constraint& c) const;
[[nodiscard]] std::string build_drop_constraint_string(const table_constraint& c) const;
static std::string build_constraint_name(const table_constraint& c);
protected:
const query_data *data_{};
include/matador/query/query_utils.hpp
+3 -3
View File
@@ -10,9 +10,9 @@ namespace matador::sql {
class dialect;
}
namespace matador::query {
class column;
class table_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);
[[nodiscard]] std::string prepare_identifier(const sql::dialect& d, const table_column &col);
[[nodiscard]] std::string prepare_criteria(const sql::dialect& d, const table_column &col);
}
#endif //MATADOR_QUERY_UTILS_HPP
include/matador/query/table.hpp
+10 -10
View File
@@ -1,7 +1,7 @@
#ifndef QUERY_TABLE_HPP
#define QUERY_TABLE_HPP
#include "matador/query/column.hpp"
#include "matador/query/table_column.hpp"
#include <string>
#include <vector>
@@ -14,7 +14,7 @@ public:
table() = default;
table(const char *name); // NOLINT(*-explicit-constructor)
table(const std::string& name); // NOLINT(*-explicit-constructor)
table(const std::string& name, const std::vector<column>& columns);
table(const std::string& name, const std::vector<table_column>& columns);
table(const table& other);
table& operator=(const table& other);
table(table&& other) noexcept;
@@ -27,30 +27,30 @@ public:
[[nodiscard]] const std::string& table_name() const;
[[nodiscard]] const std::string& name() const;
[[nodiscard]] const std::vector<column>& columns() const;
[[nodiscard]] const std::vector<table_column>& columns() const;
[[nodiscard]] bool has_alias() const;
// ReSharper disable once CppNonExplicitConversionOperator
operator const std::vector<query::column>&() const; // NOLINT(*-explicit-constructor)
operator const std::vector<query::table_column>&() const; // NOLINT(*-explicit-constructor)
const class column* operator[](const std::string& column_name) const;
static const class column* column_by_name(const table &tab, const std::string& column_name);
const table_column* operator[](const std::string& column_name) const;
static const table_column* column_by_name(const table &tab, const std::string& column_name);
protected:
static const column& create_column(class table& tab, const std::string& name);
static const table_column& create_column(class table& tab, const std::string& name);
private:
table(std::string name, std::string alias, const std::vector<column>& columns);
table(std::string name, std::string alias, const std::vector<table_column>& columns);
private:
friend class column;
friend table_column;
std::string name_;
std::string alias_;
std::string schema_name_;
std::vector<column> columns_;
std::vector<table_column> columns_;
};
table operator ""_tab(const char *name, size_t len);
include/matador/query/column.hpp → include/matador/query/table_column.hpp
+14 -14
View File
@@ -15,22 +15,22 @@ namespace matador::query {
class table;
// ReSharper disable CppNonExplicitConvertingConstructor
class column {
class table_column {
public:
column(const char *name); // NOLINT(*-explicit-constructor)
column(std::string name); // NOLINT(*-explicit-constructor)
column(std::string name, std::string alias);
column(sql::sql_function_t func, std::string name);
column(const class table* tab, std::string name);
column(const class table* tab, std::string name, std::string alias);
column(const class table* tab, std::string name, utils::basic_type type, const utils::field_attributes& attributes);
column(const class table*, std::string name, std::string alias, utils::basic_type type, const utils::field_attributes& attributes);
column& operator=(const column& other);
column(const column& other);
table_column(const char *name); // NOLINT(*-explicit-constructor)
table_column(std::string name); // NOLINT(*-explicit-constructor)
table_column(std::string name, std::string alias);
table_column(sql::sql_function_t func, std::string name);
table_column(const class table* tab, std::string name);
table_column(const class table* tab, std::string name, std::string alias);
table_column(const class table* tab, std::string name, utils::basic_type type, const utils::field_attributes& attributes);
table_column(const class table*, std::string name, std::string alias, utils::basic_type type, const utils::field_attributes& attributes);
table_column& operator=(const table_column& other);
table_column(const table_column& other);
[[nodiscard]] bool equals(const column &x) const;
[[nodiscard]] bool equals(const table_column &x) const;
column as(std::string a);
table_column as(std::string a);
[[nodiscard]] const std::string& name() const;
[[nodiscard]] const std::string& alias() const;
@@ -60,7 +60,7 @@ private:
sql::sql_function_t function_{sql::sql_function_t::None};
};
column operator ""_col(const char *name, size_t len);
table_column operator ""_col(const char *name, size_t len);
}
#endif //QUERY_COLUMN_HPP
include/matador/query/constraint.hpp → include/matador/query/table_constraint.hpp
+5 -5
View File
@@ -8,12 +8,12 @@ enum class constraints : unsigned char;
}
namespace matador::query {
class constraint {
class table_constraint {
public:
constraint() = default;
constraint(std::string column_name, std::string table_name, utils::constraints type);
constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
constraint(std::string name, std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
table_constraint() = default;
table_constraint(std::string column_name, std::string table_name, utils::constraints type);
table_constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
table_constraint(std::string name, std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
[[nodiscard]] std::string name() const;
[[nodiscard]] std::string column_name() const;
include/matador/sql/query_macro.hpp
+1 -1
View File
@@ -4,7 +4,7 @@
#include "matador/utils/macro_map.hpp"
#include "matador/query/table.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table_column.hpp"
#include <string>
#include <ostream>