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.

This commit is contained in:
Sascha Kühl 2025-12-31 13:01:06 +01:00
parent ab2d39407c
commit b9d35cbd4e
62 changed files with 424 additions and 423 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
demo/main.cpp
View File

@ -144,20 +144,20 @@ struct matador::utils::data_type_traits<job::job_mode, void> {
} }
}; };
QUERY_HELPER( authors, AUTHOR, id, first_name, last_name, date_of_birth, year_of_birth, distinguished ) // QUERY_HELPER( authors, AUTHOR, id, first_name, last_name, date_of_birth, year_of_birth, distinguished )
//
QUERY_HELPER( books, BOOK, id, author_id, title, published_in ) // QUERY_HELPER( books, BOOK, id, author_id, title, published_in )
//
QUERY_HELPER( job, JOB, id, payload, type, description, state, mode ) // QUERY_HELPER( job, JOB, id, payload, type, description, state, mode )
//
QUERY_HELPER( payload, PAYLOAD, id ) // QUERY_HELPER( payload, PAYLOAD, id )
//
QUERY_HELPER( temporary_table, TEMPORARY_TABLE, id ); // QUERY_HELPER( temporary_table, TEMPORARY_TABLE, id );
//
QUERY_HELPER(customer, CUSTOMER, id, name, email, address) // QUERY_HELPER(customer, CUSTOMER, id, name, email, address)
QUERY_HELPER(product, PRODUCT, id, title, description, price, category) // QUERY_HELPER(product, PRODUCT, id, title, description, price, category)
QUERY_HELPER(category, CATEGORY, id, title, description) // QUERY_HELPER(category, CATEGORY, id, title, description)
QUERY_HELPER(cart, CART, id, items, owner) // QUERY_HELPER(cart, CART, id, items, owner)
int main() { int main() {
using namespace matador::sql; using namespace matador::sql;

53
include/matador/orm/session.hpp
View File

@ -7,6 +7,7 @@
#include "matador/query/criteria.hpp" #include "matador/query/criteria.hpp"
#include "matador/query/query.hpp" #include "matador/query/query.hpp"
#include "matador/query/generator.hpp" #include "matador/query/generator.hpp"
#include "matador/query/schema.hpp"
#include "matador/sql/connection.hpp" #include "matador/sql/connection.hpp"
#include "matador/sql/connection_pool.hpp" #include "matador/sql/connection_pool.hpp"
@ -15,7 +16,6 @@
#include "matador/sql/statement_cache.hpp" #include "matador/sql/statement_cache.hpp"
#include "matador/object/object_ptr.hpp" #include "matador/object/object_ptr.hpp"
#include "matador/object/repository.hpp"
#include <unordered_map> #include <unordered_map>
@ -71,20 +71,13 @@ public:
} }
template<class Pointer> 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> 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> 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> 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: private:
const std::unordered_map<std::string, sql::statement> &statements_per_column_; const std::unordered_map<std::string, sql::statement> &statements_per_column_;
@ -151,7 +144,7 @@ private:
mutable sql::statement_cache cache_; mutable sql::statement_cache cache_;
const sql::dialect &dialect_; 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_; 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> template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::insert(Type *obj) { 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) { if (!info) {
return utils::failure(info.err()); return utils::failure(info.err());
} }
@ -240,14 +233,14 @@ private:
template<typename Type> template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::update( const object::object_ptr<Type>& obj ) { 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) { if (!info) {
return utils::failure(info.err()); return utils::failure(info.err());
} }
using namespace matador::utils; using namespace matador::utils;
using namespace matador::query; 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()) auto res = matador::query::query::update(info->get().name())
.set(generator::column_value_pairs<Type>()) .set(generator::column_value_pairs<Type>())
.where(col == _) .where(col == _)
@ -266,14 +259,14 @@ utils::result<object::object_ptr<Type>, utils::error> session::update( const obj
template<typename Type> template<typename Type>
utils::result<void, utils::error> session::remove( const object::object_ptr<Type>& obj ) { 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) { if (!info) {
return utils::failure(info.err()); return utils::failure(info.err());
} }
using namespace matador::utils; using namespace matador::utils;
using namespace matador::query; 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() auto res = matador::query::query::remove()
.from( info->get().name() ) .from( info->get().name() )
.where(col == _) .where(col == _)
@ -291,22 +284,24 @@ utils::result<void, utils::error> session::remove( const object::object_ptr<Type
template<typename Type, typename PrimaryKeyType> template<typename Type, typename PrimaryKeyType>
utils::result<object::object_ptr<Type>, utils::error> session::find(const PrimaryKeyType& pk) { utils::result<object::object_ptr<Type>, utils::error> session::find(const PrimaryKeyType& pk) {
auto info = schema_->info<Type>(); const auto it = schema_->find(typeid(Type));
if (!info) { if (it == schema_->end()) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type.")); 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.")); 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); 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; using namespace matador::query;
auto data = eqb.build<Type>(col == utils::_); auto data = eqb.build<Type>(c == utils::_);
if (!data.is_ok()) { 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); 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>(); auto stmt_result = res->bind(0, const_cast<PrimaryKeyType&>(pk)).template fetch_one<Type>();
if (stmt_result && !stmt_result.value()) { 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() }); return utils::ok(object::object_ptr<Type>{ stmt_result->release() });
} }
template<typename Type> template<typename Type>
utils::result<sql::query_result<Type>, utils::error> session::find(query::criteria_ptr clause) { 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) { if (!info) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type.")); 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> template<typename Type>
utils::result<void, utils::error> session::drop_table() { utils::result<void, utils::error> session::drop_table() {
auto info = schema_->info<Type>(); auto info = schema_->repo().info<Type>();
if (info) { if (info) {
return drop_table(info->get().name()); return drop_table(info->get().name());
} }

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

@ -26,7 +26,7 @@ namespace matador::orm {
struct entity_query_data { struct entity_query_data {
const query::table* root_table{nullptr}; const query::table* root_table{nullptr};
std::string pk_column_name{}; 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::unordered_map<std::string, sql::statement> lazy_loading_statements{};
std::vector<query::join_data> joins{}; std::vector<query::join_data> joins{};
query::criteria_ptr where_clause{}; query::criteria_ptr where_clause{};
@ -144,8 +144,8 @@ public:
} }
append_join( append_join(
query::column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, query::table_column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()},
query::column{&next->second, join_column} query::table_column{&next->second, join_column}
); );
@ -210,12 +210,12 @@ public:
} }
append_join( append_join(
query::column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, query::table_column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()},
query::column{&relation->second, join_column} query::table_column{&relation->second, join_column}
); );
append_join( append_join(
query::column{&relation->second, inverse_join_column}, query::table_column{&relation->second, inverse_join_column},
query::column{&next->second, result->second.node().info().primary_key_attribute()->name()} 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>(); const auto join_columns = join_columns_collector_.collect<typename ContainerType::value_type::value_type>();
append_join( append_join(
query::column{&table_info_stack_.top().table, table_info_stack_.top().info.primary_key_attribute()->name()}, query::table_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{&relation->second, join_columns.inverse_join_column}
); );
append_join( append_join(
query::column{&relation->second, join_columns.join_column}, query::table_column{&relation->second, join_columns.join_column},
query::column{&next->second, result->second.node().info().primary_key_attribute()->name()} 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); void push(const std::string &column_name);
static std::string build_alias(char prefix, unsigned int count); static std::string build_alias(char prefix, unsigned int count);
[[nodiscard]] bool is_root_entity() const; [[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: private:
struct table_info { struct table_info {
@ -317,8 +317,8 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u
table_info_stack_.pop(); table_info_stack_.pop();
append_join( append_join(
query::column{&table_info_stack_.top().table, id}, query::table_column{&table_info_stack_.top().table, id},
query::column{&next->second, info.primary_key_attribute()->name()} query::table_column{&next->second, info.primary_key_attribute()->name()}
); );
} else { } else {
push(id); push(id);
@ -327,7 +327,7 @@ void session_query_builder::on_foreign_object(const char *id, Pointer &, const u
// create select query // create select query
auto result = matador::query::query::select(generator::columns<typename Pointer::value_type>(schema_, generator::column_generator_options::ForceLazy)) auto result = matador::query::query::select(generator::columns<typename Pointer::value_type>(schema_, generator::column_generator_options::ForceLazy))
.from(foreign_table) .from(foreign_table)
.where(column(&foreign_table, info.primary_key_attribute()->name(), "") == _) .where(table_column(&foreign_table, info.primary_key_attribute()->name(), "") == _)
.prepare(executor_); .prepare(executor_);
if (!result) { if (!result) {
throw query_builder_exception(query_build_error::QueryError, result.release_error()); throw query_builder_exception(query_build_error::QueryError, result.release_error());

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

@ -1,8 +1,8 @@
#ifndef MATADOR_BUILDER_HPP #ifndef MATADOR_BUILDER_HPP
#define MATADOR_BUILDER_HPP #define MATADOR_BUILDER_HPP
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "matador/query/constraint.hpp" #include "matador/query/table_constraint.hpp"
#include "matador/query/table.hpp" #include "matador/query/table.hpp"
#include "matador/utils/basic_types.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); explicit column_builder(std::string column_name, utils::basic_type type, size_t size = 0);
// ReSharper disable once CppNonExplicitConversionOperator // ReSharper disable once CppNonExplicitConversionOperator
operator column() const; // NOLINT(*-explicit-constructor) operator table_column() const; // NOLINT(*-explicit-constructor)
column_builder& not_null(); column_builder& not_null();
column_builder& primary_key(); column_builder& primary_key();
@ -97,7 +97,7 @@ public:
constraint_builder& references(std::string table, std::string column); constraint_builder& references(std::string table, std::string column);
// ReSharper disable once CppNonExplicitConversionOperator // ReSharper disable once CppNonExplicitConversionOperator
operator class constraint() const; // NOLINT(*-explicit-constructor) operator table_constraint() const; // NOLINT(*-explicit-constructor)
private: private:
std::string constraint_name_; std::string constraint_name_;

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

@ -3,19 +3,19 @@
#include "matador/query/criteria/abstract_criteria.hpp" #include "matador/query/criteria/abstract_criteria.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
namespace matador::query { namespace matador::query {
class abstract_column_criteria : public abstract_criteria { class abstract_column_criteria : public abstract_criteria {
public: public:
abstract_column_criteria() = delete; 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: protected:
class column column_; table_column column_;
}; };
} }

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

@ -9,8 +9,8 @@ namespace matador::query {
class between_criteria final : public abstract_column_criteria { class between_criteria final : public abstract_column_criteria {
public: public:
between_criteria() = delete; between_criteria() = delete;
between_criteria(const class column& col, int64_t min, int64_t max); between_criteria(const table_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, utils::placeholder min, utils::placeholder max);
void accept(criteria_visitor& visitor) const override; void accept(criteria_visitor& visitor) const override;

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

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

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

@ -8,7 +8,7 @@
#include "matador/sql/query_context.hpp" #include "matador/sql/query_context.hpp"
namespace matador::query { namespace matador::query {
class column; class table_column;
enum class collection_operator { enum class collection_operator {
In, In,
@ -38,8 +38,8 @@ public:
* @param operand_ Operator to use * @param operand_ Operator to use
* @param values List of values * @param values List of values
*/ */
collection_criteria(const class column& col, collection_operator operand_, std::vector<criteria_value> values); collection_criteria(const table_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::initializer_list<criteria_value> values);
void accept(criteria_visitor& visitor) const override; void accept(criteria_visitor& visitor) const override;
@ -54,7 +54,7 @@ private:
class collection_query_criteria final : public abstract_column_criteria { class collection_query_criteria final : public abstract_column_criteria {
public: public:
collection_query_criteria() = delete; 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; void accept(criteria_visitor& visitor) const override;

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

@ -11,51 +11,51 @@ namespace matador::sql {
struct query_context; struct query_context;
} }
namespace matador::query { namespace matador::query {
class column; class table_column;
template<class Type> 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)); return std::make_unique<binary_criteria>(col, binary_operator::EQUALS, utils::value(val));
} }
template<class Type> 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)); return std::make_unique<binary_criteria>(col, binary_operator::NOT_EQUALS, utils::value(val));
} }
template<class Type> 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)); return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN, utils::value(val));
} }
template<class Type> 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)); return std::make_unique<binary_criteria>(col, binary_operator::GREATER_THAN_OR_EQUAL, utils::value(val));
} }
template<class Type> 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)); return std::make_unique<binary_criteria>(col, binary_operator::LESS_THAN, utils::value(val));
} }
template<class Type> 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)); 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 table_column &col_left, const table_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 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 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 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 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 class column &col, utils::placeholder p); criteria_ptr operator==(const table_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 class column &col, utils::placeholder p); criteria_ptr operator>(const table_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 class column &col, utils::placeholder p); criteria_ptr operator<(const table_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&&(criteria_ptr left, criteria_ptr right); 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); criteria_ptr operator!(criteria_ptr clause);
template < class Type > 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; std::vector<criteria_value> values;
for ( auto &&arg : args ) { for ( auto &&arg : args ) {
values.emplace_back(utils::value{std::move(arg)}); 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 <> 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 > 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; std::vector<criteria_value> values;
for ( auto &&arg : args ) { for ( auto &&arg : args ) {
values.emplace_back(utils::value{std::move(arg)}); 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 <> 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 table_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, 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 #endif //CRITERIA_CRITERIA_OPERATORS_HPP

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

@ -4,12 +4,12 @@
#include "matador/query/criteria/abstract_column_criteria.hpp" #include "matador/query/criteria/abstract_column_criteria.hpp"
namespace matador::query { namespace matador::query {
class column; class table_column;
class like_criteria final : public abstract_column_criteria { class like_criteria final : public abstract_column_criteria {
public: public:
like_criteria() = delete; 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; void accept(criteria_visitor &visitor) const override;

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

@ -50,13 +50,13 @@ public:
column_generator_options options = default_column_generator_options); column_generator_options options = default_column_generator_options);
template< class Type > template< class Type >
std::vector<column> generate() { std::vector<table_column> generate() {
Type obj; Type obj;
return generate(obj); return generate(obj);
} }
template< class Type > template< class Type >
std::vector<column> generate(const Type &obj) { std::vector<table_column> generate(const Type &obj) {
result_.clear(); result_.clear();
access::process(*this, obj); access::process(*this, obj);
@ -146,7 +146,7 @@ private:
private: private:
std::optional<std::reference_wrapper<const schema>> repo_; 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::stack<std::shared_ptr<table>> table_stack_;
std::unordered_set<std::string> seen_tables; std::unordered_set<std::string> seen_tables;
int column_index{0}; int column_index{0};
@ -293,7 +293,7 @@ std::vector<internal::column_value_pair> column_value_pairs() {
} }
template<typename Type> template<typename Type>
std::vector<column> columns(const schema &repo, std::vector<table_column> columns(const schema &repo,
const std::string &table_name = "", const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) { const column_generator_options options = default_column_generator_options) {
column_generator generator(repo, table_name, options); column_generator generator(repo, table_name, options);
@ -301,7 +301,7 @@ std::vector<column> columns(const schema &repo,
} }
template<typename Type> template<typename Type>
std::vector<column> columns(const schema &repo, std::vector<table_column> columns(const schema &repo,
const column_generator_options options) { const column_generator_options options) {
std::string table_name; std::string table_name;
if (const auto result = repo.repo().info<Type>()) { if (const auto result = repo.repo().info<Type>()) {
@ -312,7 +312,7 @@ std::vector<column> columns(const schema &repo,
} }
template<typename Type> template<typename Type>
std::vector<column> columns(const Type &obj, std::vector<table_column> columns(const Type &obj,
const schema &repo, const schema &repo,
const std::string &table_name = "", const std::string &table_name = "",
const column_generator_options options = default_column_generator_options) { const column_generator_options options = default_column_generator_options) {

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

@ -3,7 +3,7 @@
#include "matador/query/intermediates/executable_query.hpp" #include "matador/query/intermediates/executable_query.hpp"
#include "matador/query/intermediates/query_intermediate.hpp" #include "matador/query/intermediates/query_intermediate.hpp"
#include "matador/query/constraint.hpp" #include "matador/query/table_constraint.hpp"
#include "matador/object/restriction.hpp" #include "matador/object/restriction.hpp"
@ -16,21 +16,21 @@ class query_add_foreign_key_constraint_intermediate final : public query_interme
public: public:
using query_intermediate::query_intermediate; 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: private:
table table_; table table_;
std::vector<column> columns_; std::vector<table_column> columns_;
}; };
class query_add_key_constraint_intermediate final : public query_intermediate { class query_add_key_constraint_intermediate final : public query_intermediate {
public: public:
using query_intermediate::query_intermediate; 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_key(const table_column& col) const;
[[nodiscard]] query_add_primary_key_constraint_intermediate primary_keys(const std::vector<column>& columns) 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 column& col) 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<column>& columns) 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 { class query_alter_table_intermediate final : public query_intermediate {

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

@ -5,7 +5,7 @@
#include "matador/query/intermediates/executable_query.hpp" #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/attribute.hpp"
#include "matador/object/restriction.hpp" #include "matador/object/restriction.hpp"
@ -20,8 +20,8 @@ public:
executable_query constraints(std::initializer_list<object::restriction> constraints); executable_query constraints(std::initializer_list<object::restriction> constraints);
executable_query constraints(const std::list<object::restriction> &restrictions); executable_query constraints(const std::list<object::restriction> &restrictions);
executable_query constraints(std::initializer_list<constraint> constraints); executable_query constraints(std::initializer_list<table_constraint> constraints);
executable_query constraints(const std::list<constraint> &restrictions); executable_query constraints(const std::list<table_constraint> &restrictions);
}; };
class query_create_table_intermediate : public query_intermediate { 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(std::initializer_list<object::attribute> attributes);
query_create_table_columns_intermediate columns(const std::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(std::initializer_list<table_column> columns);
query_create_table_columns_intermediate columns(const std::list<column> &columns); query_create_table_columns_intermediate columns(const std::list<table_column> &columns);
}; };
class query_create_intermediate : public query_intermediate { class query_create_intermediate : public query_intermediate {

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

@ -14,7 +14,7 @@ public:
using executable_query::executable_query; using executable_query::executable_query;
query_execute_limit_intermediate limit(size_t limit); 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);
}; };
} }

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

@ -25,8 +25,8 @@ public:
// return where_clause(std::make_unique<Condition>(std::move(cond))); // return where_clause(std::make_unique<Condition>(std::move(cond)));
// } // }
query_where_intermediate where(std::unique_ptr<abstract_criteria> &&cond); query_where_intermediate where(std::unique_ptr<abstract_criteria> &&cond);
query_group_by_intermediate group_by(const column &col); query_group_by_intermediate group_by(const table_column &col);
query_order_by_intermediate order_by(const column &col); query_order_by_intermediate order_by(const table_column &col);
private: private:
query_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond); query_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);

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

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

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

@ -16,8 +16,8 @@ public:
query_into_intermediate into(const table &tab, const schema &scm) { query_into_intermediate into(const table &tab, const schema &scm) {
return into(tab, generator::columns<Type>(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::initializer_list<table_column> columns);
query_into_intermediate into(const table &tab, std::vector<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, const std::vector<std::string> &column_names);
query_into_intermediate into(const table &tab); query_into_intermediate into(const table &tab);
}; };

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

@ -10,7 +10,7 @@ class query_from_intermediate;
class query_select_intermediate : public query_intermediate class query_select_intermediate : public query_intermediate
{ {
public: 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); query_from_intermediate from(const table& t);
}; };

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

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

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

@ -1,7 +1,7 @@
#ifndef QUERY_KEY_VALUE_PAIR_HPP #ifndef QUERY_KEY_VALUE_PAIR_HPP
#define 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/placeholder.hpp"
#include "matador/utils/types.hpp" #include "matador/utils/types.hpp"
@ -10,7 +10,7 @@ namespace matador::query::internal {
class column_value_pair { class column_value_pair {
public: 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(std::string name, utils::database_type value);
column_value_pair(const char *name, utils::database_type value); column_value_pair(const char *name, utils::database_type value);
column_value_pair(const char *name, utils::placeholder p); 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);
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; [[nodiscard]] const std::variant<utils::placeholder, utils::database_type>& value() const;
private: private:
column column_; table_column column_;
std::variant<utils::placeholder, utils::database_type> value_; std::variant<utils::placeholder, utils::database_type> value_;
}; };

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

@ -6,8 +6,8 @@
#include "matador/query/internal/column_value_pair.hpp" #include "matador/query/internal/column_value_pair.hpp"
#include "matador/query/query_part.hpp" #include "matador/query/query_part.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "matador/query/constraint.hpp" #include "matador/query/table_constraint.hpp"
#include "matador/query/table.hpp" #include "matador/query/table.hpp"
#include "matador/utils/placeholder.hpp" #include "matador/utils/placeholder.hpp"
@ -50,12 +50,12 @@ private:
class query_add_constraint_part_by_constraint final : public query_part { class query_add_constraint_part_by_constraint final : public query_part {
public: 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; void accept(query_part_visitor &visitor) override;
[[nodiscard]] const class constraint& constraint() const; [[nodiscard]] const table_constraint& constraint() const;
private: private:
class constraint constraint_; table_constraint constraint_;
}; };
class query_drop_key_constraint_part_by_name final : public query_part { 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 { class query_drop_key_constraint_part_by_constraint final : public query_part {
public: 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; void accept(query_part_visitor &visitor) override;
[[nodiscard]] const class constraint& constraint() const; [[nodiscard]] const table_constraint& constraint() const;
private: private:
class constraint constraint_; table_constraint constraint_;
}; };
class query_add_foreign_key_constraint_part final : public query_part { class query_add_foreign_key_constraint_part final : public query_part {
public: 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; void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const; [[nodiscard]] const std::vector<table_column>& columns() const;
private: private:
std::vector<column> columns_; std::vector<table_column> columns_;
}; };
class query_add_foreign_key_reference_part final : public query_part { class query_add_foreign_key_reference_part final : public query_part {
public: 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; void accept(query_part_visitor &visitor) override;
[[nodiscard]] const class table& table() const; [[nodiscard]] const class table& table() const;
[[nodiscard]] const std::vector<column>& columns() const; [[nodiscard]] const std::vector<table_column>& columns() const;
private: private:
query::table table_; query::table table_;
std::vector<column> columns_; std::vector<table_column> columns_;
}; };
class query_add_primary_key_constraint_part final : public query_part { class query_add_primary_key_constraint_part final : public query_part {
public: 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; void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const; [[nodiscard]] const std::vector<table_column>& columns() const;
private: private:
std::vector<column> columns_; std::vector<table_column> columns_;
}; };
/** /**
@ -117,13 +117,13 @@ private:
class query_select_part final : public query_part class query_select_part final : public query_part
{ {
public: 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; void accept(query_part_visitor &visitor) override;
[[nodiscard]] const std::vector<column>& columns() const; [[nodiscard]] const std::vector<table_column>& columns() const;
private: private:
std::vector<column> columns_; std::vector<table_column> columns_;
}; };
/** /**
@ -205,29 +205,29 @@ protected:
class query_group_by_part final : public query_part class query_group_by_part final : public query_part
{ {
public: 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: private:
void accept(query_part_visitor &visitor) override; void accept(query_part_visitor &visitor) override;
private: private:
class column column_; table_column column_;
}; };
class query_order_by_part final : public query_part class query_order_by_part final : public query_part
{ {
public: 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: private:
void accept(query_part_visitor &visitor) override; void accept(query_part_visitor &visitor) override;
private: private:
class column column_; table_column column_;
}; };
class query_order_by_asc_part final : public query_part class query_order_by_asc_part final : public query_part
@ -288,17 +288,17 @@ private:
class query_into_part final : public query_part class query_into_part final : public query_part
{ {
public: 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 class table& table() const;
[[nodiscard]] const std::vector<column>& columns() const; [[nodiscard]] const std::vector<table_column>& columns() const;
private: private:
void accept(query_part_visitor &visitor) override; void accept(query_part_visitor &visitor) override;
private: private:
class table table_; class table table_;
std::vector<column> columns_; std::vector<table_column> columns_;
}; };
/** /**
* Represents the SQL VALUES part * Represents the SQL VALUES part
@ -393,28 +393,28 @@ private:
class query_create_table_columns_part final : public query_part { class query_create_table_columns_part final : public query_part {
public: 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: private:
void accept(query_part_visitor &visitor) override; void accept(query_part_visitor &visitor) override;
private: private:
std::list<column> columns_; std::list<table_column> columns_;
}; };
class query_create_table_constraints_part final : public query_part { class query_create_table_constraints_part final : public query_part {
public: 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: private:
void accept(query_part_visitor &visitor) override; void accept(query_part_visitor &visitor) override;
private: private:
std::list<constraint> constraints_; std::list<table_constraint> constraints_;
}; };
class query_create_schema_part final : public query_part { class query_create_schema_part final : public query_part {

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

@ -11,10 +11,10 @@ class connection;
} }
namespace matador::query { namespace matador::query {
column alias(const std::string &column, const std::string &as); table_column alias(const std::string &column, const std::string &as);
column alias(column &&col, const std::string &as); table_column alias(table_column &&col, const std::string &as);
column count(const std::string &column); table_column count(const std::string &column);
column count_all(); table_column count_all();
class query class query
{ {
@ -22,10 +22,10 @@ public:
[[nodiscard]] static query_create_intermediate create(); [[nodiscard]] static query_create_intermediate create();
[[nodiscard]] static query_drop_intermediate drop(); [[nodiscard]] static query_drop_intermediate drop();
[[nodiscard]] static query_select_intermediate select(); [[nodiscard]] static query_select_intermediate select();
[[nodiscard]] static query_select_intermediate select(std::initializer_list<column> columns); [[nodiscard]] static query_select_intermediate select(std::initializer_list<table_column> columns);
[[nodiscard]] static query_select_intermediate select(const std::vector<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(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> template<class Type>
[[nodiscard]] static query_select_intermediate select(const schema &scm) { [[nodiscard]] static query_select_intermediate select(const schema &scm) {
return select(generator::columns<Type>(scm)); return select(generator::columns<Type>(scm));

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

@ -22,6 +22,8 @@ namespace internal {
struct basic_type_to_string_visitor; struct basic_type_to_string_visitor;
} }
class table_constraint;
struct query_data; struct query_data;
struct value_visitor; 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 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); 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; [[nodiscard]] std::string build_add_constraint_string(const table_constraint& c) const;
std::string build_drop_constraint_string(const class constraint& c) const; [[nodiscard]] std::string build_drop_constraint_string(const table_constraint& c) const;
static std::string build_constraint_name(const class constraint& c); static std::string build_constraint_name(const table_constraint& c);
protected: protected:
const query_data *data_{}; const query_data *data_{};

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

@ -10,9 +10,9 @@ namespace matador::sql {
class dialect; class dialect;
} }
namespace matador::query { namespace matador::query {
class column; class table_column;
[[nodiscard]] std::string prepare_identifier(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 column &col); [[nodiscard]] std::string prepare_criteria(const sql::dialect& d, const table_column &col);
} }
#endif //MATADOR_QUERY_UTILS_HPP #endif //MATADOR_QUERY_UTILS_HPP

20
include/matador/query/table.hpp
View File

@ -1,7 +1,7 @@
#ifndef QUERY_TABLE_HPP #ifndef QUERY_TABLE_HPP
#define QUERY_TABLE_HPP #define QUERY_TABLE_HPP
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include <string> #include <string>
#include <vector> #include <vector>
@ -14,7 +14,7 @@ public:
table() = default; table() = default;
table(const char *name); // NOLINT(*-explicit-constructor) table(const char *name); // NOLINT(*-explicit-constructor)
table(const std::string& 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(const table& other);
table& operator=(const table& other); table& operator=(const table& other);
table(table&& other) noexcept; table(table&& other) noexcept;
@ -27,30 +27,30 @@ public:
[[nodiscard]] const std::string& table_name() const; [[nodiscard]] const std::string& table_name() const;
[[nodiscard]] const std::string& 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; [[nodiscard]] bool has_alias() const;
// ReSharper disable once CppNonExplicitConversionOperator // 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; const table_column* operator[](const std::string& column_name) const;
static const class column* column_by_name(const table &tab, const std::string& column_name); static const table_column* column_by_name(const table &tab, const std::string& column_name);
protected: 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: 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: private:
friend class column; friend table_column;
std::string name_; std::string name_;
std::string alias_; std::string alias_;
std::string schema_name_; std::string schema_name_;
std::vector<column> columns_; std::vector<table_column> columns_;
}; };
table operator ""_tab(const char *name, size_t len); table operator ""_tab(const char *name, size_t len);

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

@ -15,22 +15,22 @@ namespace matador::query {
class table; class table;
// ReSharper disable CppNonExplicitConvertingConstructor // ReSharper disable CppNonExplicitConvertingConstructor
class column { class table_column {
public: public:
column(const char *name); // NOLINT(*-explicit-constructor) table_column(const char *name); // NOLINT(*-explicit-constructor)
column(std::string name); // NOLINT(*-explicit-constructor) table_column(std::string name); // NOLINT(*-explicit-constructor)
column(std::string name, std::string alias); table_column(std::string name, std::string alias);
column(sql::sql_function_t func, std::string name); table_column(sql::sql_function_t func, std::string name);
column(const class table* tab, std::string name); table_column(const class table* tab, std::string name);
column(const class table* tab, std::string name, std::string alias); table_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); table_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); table_column(const class table*, std::string name, std::string alias, utils::basic_type type, const utils::field_attributes& attributes);
column& operator=(const column& other); table_column& operator=(const table_column& other);
column(const 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& name() const;
[[nodiscard]] const std::string& alias() const; [[nodiscard]] const std::string& alias() const;
@ -60,7 +60,7 @@ private:
sql::sql_function_t function_{sql::sql_function_t::None}; 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 #endif //QUERY_COLUMN_HPP

10
include/matador/query/constraint.hpp → include/matador/query/table_constraint.hpp
View File

@ -8,12 +8,12 @@ enum class constraints : unsigned char;
} }
namespace matador::query { namespace matador::query {
class constraint { class table_constraint {
public: public:
constraint() = default; table_constraint() = default;
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);
constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column); table_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(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 name() const;
[[nodiscard]] std::string column_name() const; [[nodiscard]] std::string column_name() const;

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

@ -4,7 +4,7 @@
#include "matador/utils/macro_map.hpp" #include "matador/utils/macro_map.hpp"
#include "matador/query/table.hpp" #include "matador/query/table.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include <string> #include <string>
#include <ostream> #include <ostream>

8
source/orm/CMakeLists.txt
View File

@ -4,8 +4,6 @@ add_library(matador-orm STATIC
../../include/matador/orm/session_query_builder.hpp ../../include/matador/orm/session_query_builder.hpp
../../include/matador/query/attribute_string_writer.hpp ../../include/matador/query/attribute_string_writer.hpp
../../include/matador/query/builder.hpp ../../include/matador/query/builder.hpp
../../include/matador/query/column.hpp
../../include/matador/query/constraint.hpp
../../include/matador/query/criteria.hpp ../../include/matador/query/criteria.hpp
../../include/matador/query/criteria/abstract_column_criteria.hpp ../../include/matador/query/criteria/abstract_column_criteria.hpp
../../include/matador/query/criteria/abstract_criteria.hpp ../../include/matador/query/criteria/abstract_criteria.hpp
@ -59,6 +57,8 @@ add_library(matador-orm STATIC
../../include/matador/query/query_utils.hpp ../../include/matador/query/query_utils.hpp
../../include/matador/query/schema.hpp ../../include/matador/query/schema.hpp
../../include/matador/query/table.hpp ../../include/matador/query/table.hpp
../../include/matador/query/table_column.hpp
../../include/matador/query/table_constraint.hpp
../../include/matador/query/value_extractor.hpp ../../include/matador/query/value_extractor.hpp
../../include/matador/sql/abstract_sql_logger.hpp ../../include/matador/sql/abstract_sql_logger.hpp
../../include/matador/sql/backend_provider.hpp ../../include/matador/sql/backend_provider.hpp
@ -90,8 +90,6 @@ add_library(matador-orm STATIC
orm/session_query_builder.cpp orm/session_query_builder.cpp
query/attribute_string_writer.cpp query/attribute_string_writer.cpp
query/builder.cpp query/builder.cpp
query/column.cpp
query/constraint.cpp
query/criteria/abstract_column_criteria.cpp query/criteria/abstract_column_criteria.cpp
query/criteria/between_criteria.cpp query/criteria/between_criteria.cpp
query/criteria/binary_criteria.cpp query/criteria/binary_criteria.cpp
@ -140,6 +138,8 @@ add_library(matador-orm STATIC
query/query_utils.cpp query/query_utils.cpp
query/schema.cpp query/schema.cpp
query/table.cpp query/table.cpp
query/table_column.cpp
query/table_constraint.cpp
query/value_extractor.cpp query/value_extractor.cpp
sql/backend_provider.cpp sql/backend_provider.cpp
sql/connection.cpp sql/connection.cpp

12
source/orm/orm/session.cpp
View File

@ -15,7 +15,7 @@ utils::error make_error(const error_code ec, const std::string &msg) {
session::session(session_context&& ctx) session::session(session_context&& ctx)
: cache_(ctx.bus, ctx.pool, ctx.cache_size) : cache_(ctx.bus, ctx.pool, ctx.cache_size)
, dialect_(sql::backend_provider::instance().connection_dialect(ctx.pool.info().type)) , dialect_(sql::backend_provider::instance().connection_dialect(ctx.pool.info().type))
, schema_(std::make_unique<object::repository>(dialect_.default_schema_name())) { , schema_(std::make_unique<query::schema>(dialect_.default_schema_name())) {
} }
utils::result<void, utils::error> session::create_schema() const { utils::result<void, utils::error> session::create_schema() const {
@ -49,7 +49,7 @@ utils::result<void, utils::error> session::create_schema() const {
// } // }
auto c = cache_.pool().acquire(); auto c = cache_.pool().acquire();
for (const auto &node: *schema_) { for (const auto &node: schema_->repo()) {
auto ctx = query::query::create() auto ctx = query::query::create()
.table(node->name()) .table(node->name())
.columns(node->info().attributes()) .columns(node->info().attributes())
@ -62,7 +62,7 @@ utils::result<void, utils::error> session::create_schema() const {
} }
// create table constraints // create table constraints
for (const auto &node: *schema_) { for (const auto &node: schema_->repo()) {
for (const auto& cons : node->info().constraints()) { for (const auto& cons : node->info().constraints()) {
auto ctx = build_add_constraint_context(node->name(), cons, c); auto ctx = build_add_constraint_context(node->name(), cons, c);
@ -95,7 +95,7 @@ sql::query_context session::build_add_constraint_context(const std::string& tabl
utils::result<void, utils::error> session::drop_schema() const { utils::result<void, utils::error> session::drop_schema() const {
auto c = cache_.pool().acquire(); auto c = cache_.pool().acquire();
// drop table constraints // drop table constraints
for (const auto &node: *schema_) { for (const auto &node: schema_->repo()) {
for (const auto& cons : node->info().constraints()) { for (const auto& cons : node->info().constraints()) {
auto ctx = query::query::alter() auto ctx = query::query::alter()
.table(node->name()) .table(node->name())
@ -110,7 +110,7 @@ utils::result<void, utils::error> session::drop_schema() const {
} }
// drop table // drop table
for (const auto &node: *schema_) { for (const auto &node: schema_->repo()) {
auto ctx = query::query::drop() auto ctx = query::query::drop()
.table(node->name()) .table(node->name())
.compile(*c); .compile(*c);
@ -191,7 +191,7 @@ const class sql::dialect &session::dialect() const {
} }
void session::dump_schema(std::ostream &os) const { void session::dump_schema(std::ostream &os) const {
schema_->dump(os); schema_->repo().dump(os);
} }
utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> session::fetch(const sql::query_context& ctx) const { utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> session::fetch(const sql::query_context& ctx) const {

4
source/orm/orm/session_query_builder.cpp
View File

@ -47,7 +47,7 @@ void criteria_transformer::update_criteria_column(const query::abstract_column_c
return; return;
} }
const_cast<query::column&>(node.col()).table(&it->second); const_cast<query::table_column&>(node.col()).table(&it->second);
} }
void session_query_builder::on_revision(const char *id, uint64_t &/*rev*/) { void session_query_builder::on_revision(const char *id, uint64_t &/*rev*/) {
@ -73,7 +73,7 @@ std::string session_query_builder::build_alias(const char prefix, const unsigned
return table_info_stack_.size() == 1; return table_info_stack_.size() == 1;
} }
void session_query_builder::append_join(const query::column &left, const query::column &right) { void session_query_builder::append_join(const query::table_column &left, const query::table_column &right) {
using namespace matador::query; using namespace matador::query;
entity_query_data_.joins.push_back({ entity_query_data_.joins.push_back({
right.table(), right.table(),

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

@ -7,7 +7,7 @@ column_builder::column_builder(std::string column_name, const utils::basic_type
, type_(type) , type_(type)
, size_(size) {} , size_(size) {}
column_builder::operator class query::column() const { column_builder::operator class query::table_column() const {
return {nullptr, column_name_, type_, {size_, constraints_}}; return {nullptr, column_name_, type_, {size_, constraints_}};
} }
@ -57,7 +57,7 @@ constraint_builder& constraint_builder::references( std::string table, std::stri
return *this; return *this;
} }
constraint_builder::operator class constraint() const { constraint_builder::operator table_constraint() const {
return {constraint_name_, column_name_, ref_table_name_, type_, ref_table_name_, ref_column_name_}; return {constraint_name_, column_name_, ref_table_name_, type_, ref_table_name_, ref_column_name_};
} }

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

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

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

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

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

@ -3,7 +3,7 @@
#include "matador/query/criteria/criteria_visitor.hpp" #include "matador/query/criteria/criteria_visitor.hpp"
namespace matador::query { namespace matador::query {
binary_criteria::binary_criteria(const class column& col, const binary_operator operand, criteria_value value) binary_criteria::binary_criteria(const table_column& col, const binary_operator operand, criteria_value value)
: abstract_column_criteria(col) : abstract_column_criteria(col)
, operator_(operand) , operator_(operand)
, value_(std::move(value)) , value_(std::move(value))
@ -21,7 +21,7 @@ const criteria_value& binary_criteria::value() const {
return value_; return value_;
} }
binary_column_criteria::binary_column_criteria(const class column& left_column, const binary_operator operand, const class column& right_column) binary_column_criteria::binary_column_criteria(const table_column& left_column, const binary_operator operand, const table_column& right_column)
: left_column_(left_column) : left_column_(left_column)
, operator_(operand) , operator_(operand)
, right_column_(right_column){} , right_column_(right_column){}
@ -30,7 +30,7 @@ void binary_column_criteria::accept(criteria_visitor& visitor) const {
visitor.visit(*this); visitor.visit(*this);
} }
const class column& binary_column_criteria::left_column() const { const table_column& binary_column_criteria::left_column() const {
return left_column_; return left_column_;
} }
@ -38,7 +38,7 @@ binary_operator binary_column_criteria::operand() const {
return operator_; return operator_;
} }
const class column& binary_column_criteria::right_column() const { const table_column& binary_column_criteria::right_column() const {
return right_column_; return right_column_;
} }
} }

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

@ -1,16 +1,16 @@
#include "matador/query/criteria/collection_criteria.hpp" #include "matador/query/criteria/collection_criteria.hpp"
#include "matador/query/criteria/criteria_visitor.hpp" #include "matador/query/criteria/criteria_visitor.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
namespace matador::query { namespace matador::query {
collection_criteria::collection_criteria(const class column& col, const collection_operator operand_, std::vector<criteria_value> values ) collection_criteria::collection_criteria(const table_column& col, const collection_operator operand_, std::vector<criteria_value> values )
: abstract_column_criteria(col) : abstract_column_criteria(col)
, operand_(operand_) , operand_(operand_)
, values_(std::move(values)) , values_(std::move(values))
{} {}
collection_criteria::collection_criteria(const class column& col, const collection_operator operand_, const std::initializer_list<criteria_value> values ) collection_criteria::collection_criteria(const table_column& col, const collection_operator operand_, const std::initializer_list<criteria_value> values )
: abstract_column_criteria(col) : abstract_column_criteria(col)
, operand_(operand_) , operand_(operand_)
, values_(values) , values_(values)
@ -28,7 +28,7 @@ const std::vector<criteria_value>& collection_criteria::values() const {
return values_; return values_;
} }
collection_query_criteria::collection_query_criteria(const class column& col, collection_operator operand_, sql::query_context ctx) collection_query_criteria::collection_query_criteria(const table_column& col, collection_operator operand_, sql::query_context ctx)
: abstract_column_criteria(col) : abstract_column_criteria(col)
, operand_(operand_) , operand_(operand_)
, query_context_(std::move(ctx)){ , query_context_(std::move(ctx)){

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

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

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

@ -1,10 +1,10 @@
#include "matador/query/criteria/like_criteria.hpp" #include "matador/query/criteria/like_criteria.hpp"
#include "matador/query/criteria/criteria_visitor.hpp" #include "matador/query/criteria/criteria_visitor.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
namespace matador::query { namespace matador::query {
like_criteria::like_criteria(const class column& col, std::string pattern) like_criteria::like_criteria(const table_column& col, std::string pattern)
: abstract_column_criteria(col) : abstract_column_criteria(col)
, pattern_(std::move(pattern)){} , pattern_(std::move(pattern)){}

14
source/orm/query/intermediates/query_alter_table_intermediate.cpp
View File

@ -4,27 +4,27 @@
#include "matador/query/internal/query_parts.hpp" #include "matador/query/internal/query_parts.hpp"
namespace matador::query { namespace matador::query {
executable_query query_add_foreign_key_constraint_intermediate::references( const table& tab, const std::vector<column>& columns) { executable_query query_add_foreign_key_constraint_intermediate::references( const table& tab, const std::vector<table_column>& columns) {
context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_reference_part>(tab, columns)); context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_reference_part>(tab, columns));
return {context_}; return {context_};
} }
query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const column& col) const { query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_key(const table_column& col) const {
return primary_keys({col}); return primary_keys({col});
} }
query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<column>& columns) const { query_add_primary_key_constraint_intermediate query_add_key_constraint_intermediate::primary_keys( const std::vector<table_column>& columns) const {
context_->parts.push_back(std::make_unique<internal::query_add_primary_key_constraint_part>(columns)); context_->parts.push_back(std::make_unique<internal::query_add_primary_key_constraint_part>(columns));
return {context_}; return {context_};
} }
query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const column& col) const { query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_key(const table_column& col) const {
return foreign_keys({col}); return foreign_keys({col});
} }
query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys(const std::vector<column>& columns) const { query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermediate::foreign_keys(const std::vector<table_column>& columns) const {
context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_constraint_part>(columns)); context_->parts.push_back(std::make_unique<internal::query_add_foreign_key_constraint_part>(columns));
return {context_}; return {context_};
@ -32,7 +32,7 @@ query_add_foreign_key_constraint_intermediate query_add_key_constraint_intermedi
executable_query query_alter_table_intermediate::add_constraint(const object::restriction &rest) { executable_query query_alter_table_intermediate::add_constraint(const object::restriction &rest) {
context_->parts.push_back(std::make_unique<internal::query_add_constraint_part_by_constraint>( context_->parts.push_back(std::make_unique<internal::query_add_constraint_part_by_constraint>(
constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()} table_constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()}
)); ));
return {context_}; return {context_};
@ -46,7 +46,7 @@ query_add_key_constraint_intermediate query_alter_table_intermediate::add_constr
executable_query query_alter_table_intermediate::drop_constraint(const object::restriction &rest) { executable_query query_alter_table_intermediate::drop_constraint(const object::restriction &rest) {
context_->parts.push_back(std::make_unique<internal::query_drop_key_constraint_part_by_constraint>( context_->parts.push_back(std::make_unique<internal::query_drop_key_constraint_part_by_constraint>(
constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()}) table_constraint{rest.column_name(), rest.owner()->name(), rest.attribute().attributes().options(), rest.ref_table_name(), rest.ref_column_name()})
); );
return {context_}; return {context_};
} }

14
source/orm/query/intermediates/query_create_intermediate.cpp
View File

@ -2,7 +2,7 @@
#include "matador/query/internal/query_parts.hpp" #include "matador/query/internal/query_parts.hpp"
#include "matador/query/constraint.hpp" #include "matador/query/table_constraint.hpp"
#include "matador/object/object.hpp" #include "matador/object/object.hpp"
@ -28,17 +28,17 @@ executable_query query_create_table_columns_intermediate::constraints(const std:
return this->constraints(std::list(constraints)); return this->constraints(std::list(constraints));
} }
executable_query query_create_table_columns_intermediate::constraints(const std::initializer_list<constraint> constraints) { executable_query query_create_table_columns_intermediate::constraints(const std::initializer_list<table_constraint> constraints) {
return this->constraints(std::list(constraints)); return this->constraints(std::list(constraints));
} }
executable_query query_create_table_columns_intermediate::constraints(const std::list<constraint>& constraints){ executable_query query_create_table_columns_intermediate::constraints(const std::list<table_constraint>& constraints){
context_->parts.push_back(std::make_unique<internal::query_create_table_constraints_part>(constraints)); context_->parts.push_back(std::make_unique<internal::query_create_table_constraints_part>(constraints));
return {context_}; return {context_};
} }
executable_query query_create_table_columns_intermediate::constraints(const std::list<object::restriction>& restrictions) { executable_query query_create_table_columns_intermediate::constraints(const std::list<object::restriction>& restrictions) {
std::list<constraint> constraints; std::list<table_constraint> constraints;
for (const auto& restr : restrictions) { for (const auto& restr : restrictions) {
if (restr.is_primary_key_constraint()) { if (restr.is_primary_key_constraint()) {
constraints.emplace_back(restr.column_name(), restr.owner()->name(), restr.attribute().attributes().options()); constraints.emplace_back(restr.column_name(), restr.owner()->name(), restr.attribute().attributes().options());
@ -57,7 +57,7 @@ query_create_table_columns_intermediate query_create_table_intermediate::columns
} }
query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list<object::attribute>& attributes) { query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list<object::attribute>& attributes) {
std::list<column> columns; std::list<table_column> columns;
for (const auto& attr : attributes) { for (const auto& attr : attributes) {
auto options = attr.attributes().options(); auto options = attr.attributes().options();
if (!attr.is_nullable()) { if (!attr.is_nullable()) {
@ -70,11 +70,11 @@ query_create_table_columns_intermediate query_create_table_intermediate::columns
return {context_}; return {context_};
} }
query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list<column> columns) { query_create_table_columns_intermediate query_create_table_intermediate::columns(std::initializer_list<table_column> columns) {
return this->columns(std::list(columns)); return this->columns(std::list(columns));
} }
query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list<column>& columns) { query_create_table_columns_intermediate query_create_table_intermediate::columns(const std::list<table_column>& columns) {
context_->parts.push_back(std::make_unique<internal::query_create_table_columns_part>(columns)); context_->parts.push_back(std::make_unique<internal::query_create_table_columns_part>(columns));
return {context_}; return {context_};

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

@ -12,7 +12,7 @@ query_execute_limit_intermediate query_execute_where_intermediate::limit(size_t
return {context_}; return {context_};
} }
query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const column &col) { query_execute_order_by_intermediate query_execute_where_intermediate::order_by(const table_column &col) {
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col)); context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_}; return {context_};
} }

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

@ -38,12 +38,12 @@ query_where_intermediate query_from_intermediate::where_clause(std::unique_ptr<a
return {context_}; return {context_};
} }
query_group_by_intermediate query_from_intermediate::group_by(const column &col) { query_group_by_intermediate query_from_intermediate::group_by(const table_column &col) {
context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col)); context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
return {context_}; return {context_};
} }
query_order_by_intermediate query_from_intermediate::order_by(const column &col) { query_order_by_intermediate query_from_intermediate::order_by(const table_column &col) {
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col)); context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_}; return {context_};
} }

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

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

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

@ -10,17 +10,17 @@ query_insert_intermediate::query_insert_intermediate() {
context_->parts.push_back(std::make_unique<internal::query_insert_part>()); context_->parts.push_back(std::make_unique<internal::query_insert_part>());
} }
query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list<column> columns) { query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list<table_column> columns) {
return into(tab, std::move(std::vector<column>{columns})); return into(tab, std::move(std::vector<table_column>{columns}));
} }
query_into_intermediate query_insert_intermediate::into(const table &tab, std::vector<column> &&columns) { query_into_intermediate query_insert_intermediate::into(const table &tab, std::vector<table_column> &&columns) {
context_->parts.push_back(std::make_unique<internal::query_into_part>(tab, columns)); context_->parts.push_back(std::make_unique<internal::query_into_part>(tab, columns));
return {context_}; return {context_};
} }
query_into_intermediate query_insert_intermediate::into(const table &tab, const std::vector<std::string> &column_names) { query_into_intermediate query_insert_intermediate::into(const table &tab, const std::vector<std::string> &column_names) {
std::vector<column> columns; std::vector<table_column> columns;
columns.reserve(column_names.size()); columns.reserve(column_names.size());
for (const auto &col_name : column_names) { for (const auto &col_name : column_names) {
columns.emplace_back(col_name); columns.emplace_back(col_name);

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

@ -6,7 +6,7 @@
namespace matador::query { namespace matador::query {
query_select_intermediate::query_select_intermediate(const std::vector<column>& columns) { query_select_intermediate::query_select_intermediate(const std::vector<table_column>& columns) {
context_->parts.push_back(std::make_unique<internal::query_select_part>(columns)); context_->parts.push_back(std::make_unique<internal::query_select_part>(columns));
} }

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

@ -6,12 +6,12 @@
namespace matador::query { namespace matador::query {
query_group_by_intermediate query_where_intermediate::group_by(const column &col) { query_group_by_intermediate query_where_intermediate::group_by(const table_column &col) {
context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col)); context_->parts.push_back(std::make_unique<internal::query_group_by_part>(col));
return {context_}; return {context_};
} }
query_order_by_intermediate query_where_intermediate::order_by(const column &col) { query_order_by_intermediate query_where_intermediate::order_by(const table_column &col) {
context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col)); context_->parts.push_back(std::make_unique<internal::query_order_by_part>(col));
return {context_}; return {context_};
} }

4
source/orm/query/internal/column_value_pair.cpp
View File

@ -9,7 +9,7 @@ column_value_pair::column_value_pair(std::string name, utils::database_type valu
, value_(std::move(value)) { , value_(std::move(value)) {
} }
column_value_pair::column_value_pair(const column &col, utils::database_type value) column_value_pair::column_value_pair(const table_column &col, utils::database_type value)
: column_(col) : column_(col)
, value_(std::move(value)) { , value_(std::move(value)) {
} }
@ -23,7 +23,7 @@ column_value_pair::column_value_pair( const char* name, utils::placeholder p )
: column_(name) : column_(name)
, value_(p) {} , value_(p) {}
const column &column_value_pair::col() const { const table_column &column_value_pair::col() const {
return column_; return column_;
} }

44
source/orm/query/internal/query_parts.cpp
View File

@ -34,7 +34,7 @@ const std::string& query_add_key_constraint_part::name() const {
return name_; return name_;
} }
query_add_constraint_part_by_constraint::query_add_constraint_part_by_constraint(const query::constraint &co) query_add_constraint_part_by_constraint::query_add_constraint_part_by_constraint(const query::table_constraint &co)
: query_part(sql::dialect_token::AddConstraint) : query_part(sql::dialect_token::AddConstraint)
, constraint_(co) {} , constraint_(co) {}
@ -42,7 +42,7 @@ void query_add_constraint_part_by_constraint::accept(query_part_visitor &visitor
visitor.visit(*this); visitor.visit(*this);
} }
const class constraint & query_add_constraint_part_by_constraint::constraint() const { const table_constraint & query_add_constraint_part_by_constraint::constraint() const {
return constraint_; return constraint_;
} }
@ -58,7 +58,7 @@ const std::string& query_drop_key_constraint_part_by_name::name() const {
return name_; return name_;
} }
query_drop_key_constraint_part_by_constraint::query_drop_key_constraint_part_by_constraint(const class constraint &co) query_drop_key_constraint_part_by_constraint::query_drop_key_constraint_part_by_constraint(const table_constraint &co)
: query_part( sql::dialect_token::DropConstraint ) : query_part( sql::dialect_token::DropConstraint )
, constraint_(co) {} , constraint_(co) {}
@ -66,11 +66,11 @@ void query_drop_key_constraint_part_by_constraint::accept(query_part_visitor& vi
visitor.visit(*this); visitor.visit(*this);
} }
const class constraint& query_drop_key_constraint_part_by_constraint::constraint() const { const table_constraint& query_drop_key_constraint_part_by_constraint::constraint() const {
return constraint_; return constraint_;
} }
query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<column>& columns) query_add_foreign_key_constraint_part::query_add_foreign_key_constraint_part(const std::vector<table_column>& columns)
: query_part(sql::dialect_token::ForeignKey) : query_part(sql::dialect_token::ForeignKey)
, columns_(columns) {} , columns_(columns) {}
@ -78,11 +78,11 @@ void query_add_foreign_key_constraint_part::accept( query_part_visitor& visitor
visitor.visit(*this); visitor.visit(*this);
} }
const std::vector<column>& query_add_foreign_key_constraint_part::columns() const { const std::vector<table_column>& query_add_foreign_key_constraint_part::columns() const {
return columns_; return columns_;
} }
query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<column>& columns) query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<table_column>& columns)
: query_part(sql::dialect_token::References) : query_part(sql::dialect_token::References)
, table_(std::move(tab)) , table_(std::move(tab))
, columns_(columns) {} , columns_(columns) {}
@ -95,11 +95,11 @@ const table& query_add_foreign_key_reference_part::table() const {
return table_; return table_;
} }
const std::vector<column>& query_add_foreign_key_reference_part::columns() const { const std::vector<table_column>& query_add_foreign_key_reference_part::columns() const {
return columns_; return columns_;
} }
query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<column>& columns) query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<table_column>& columns)
: query_part(sql::dialect_token::PrimaryKey) : query_part(sql::dialect_token::PrimaryKey)
, columns_(columns) {} , columns_(columns) {}
@ -107,11 +107,11 @@ void query_add_primary_key_constraint_part::accept( query_part_visitor& visitor
visitor.visit(*this); visitor.visit(*this);
} }
const std::vector<column>& query_add_primary_key_constraint_part::columns() const { const std::vector<table_column>& query_add_primary_key_constraint_part::columns() const {
return columns_; return columns_;
} }
query_select_part::query_select_part(std::vector<column> columns) query_select_part::query_select_part(std::vector<table_column> columns)
: query_part(sql::dialect_token::Select) : query_part(sql::dialect_token::Select)
, columns_(std::move(columns)) {} , columns_(std::move(columns)) {}
@ -120,7 +120,7 @@ void query_select_part::accept(query_part_visitor &visitor)
visitor.visit(*this); visitor.visit(*this);
} }
const std::vector<column>& query_select_part::columns() const const std::vector<table_column>& query_select_part::columns() const
{ {
return columns_; return columns_;
} }
@ -185,12 +185,12 @@ query_table_name_part::query_table_name_part(const sql::dialect_token token, std
: query_part(token) : query_part(token)
, table_name_(std::move(table_name)) {} , table_name_(std::move(table_name)) {}
query_group_by_part::query_group_by_part(class column col) query_group_by_part::query_group_by_part(class table_column col)
: query_part(sql::dialect_token::GroupBy) : query_part(sql::dialect_token::GroupBy)
, column_(std::move(col)) , column_(std::move(col))
{} {}
const column &query_group_by_part::column() const const table_column &query_group_by_part::column() const
{ {
return column_; return column_;
} }
@ -200,12 +200,12 @@ void query_group_by_part::accept(query_part_visitor &visitor)
visitor.visit(*this); visitor.visit(*this);
} }
query_order_by_part::query_order_by_part(class column col) query_order_by_part::query_order_by_part(class table_column col)
: query_part(sql::dialect_token::OrderBy) : query_part(sql::dialect_token::OrderBy)
, column_(std::move(col)) , column_(std::move(col))
{} {}
const column &query_order_by_part::column() const const table_column &query_order_by_part::column() const
{ {
return column_; return column_;
} }
@ -269,7 +269,7 @@ void query_insert_part::accept(query_part_visitor &visitor)
visitor.visit(*this); visitor.visit(*this);
} }
query_into_part::query_into_part(class table tab, std::vector<column> columns) query_into_part::query_into_part(class table tab, std::vector<table_column> columns)
: query_part(sql::dialect_token::Insert) : query_part(sql::dialect_token::Insert)
, table_(std::move(tab)) , table_(std::move(tab))
, columns_(std::move(columns)) {} , columns_(std::move(columns)) {}
@ -279,7 +279,7 @@ const table &query_into_part::table() const
return table_; return table_;
} }
const std::vector<column> &query_into_part::columns() const const std::vector<table_column> &query_into_part::columns() const
{ {
return columns_; return columns_;
} }
@ -375,11 +375,11 @@ void query_create_table_part::accept(query_part_visitor &visitor)
visitor.visit(*this); visitor.visit(*this);
} }
query_create_table_columns_part::query_create_table_columns_part(const std::list<column>& columns) query_create_table_columns_part::query_create_table_columns_part(const std::list<table_column>& columns)
: query_part( sql::dialect_token::Columns ) : query_part( sql::dialect_token::Columns )
, columns_(columns){} , columns_(columns){}
const std::list<column>& query_create_table_columns_part::columns() const { const std::list<table_column>& query_create_table_columns_part::columns() const {
return columns_; return columns_;
} }
@ -387,11 +387,11 @@ void query_create_table_columns_part::accept(query_part_visitor& visitor) {
visitor.visit(*this); visitor.visit(*this);
} }
query_create_table_constraints_part::query_create_table_constraints_part(const std::list<class constraint>& constraints) query_create_table_constraints_part::query_create_table_constraints_part(const std::list<class table_constraint>& constraints)
: query_part( sql::dialect_token::Constraint ) : query_part( sql::dialect_token::Constraint )
, constraints_(constraints) {} , constraints_(constraints) {}
const std::list<class constraint>& query_create_table_constraints_part::constraints() const { const std::list<class table_constraint>& query_create_table_constraints_part::constraints() const {
return constraints_; return constraints_;
} }

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

@ -2,20 +2,20 @@
namespace matador::query { namespace matador::query {
column alias(const std::string &column, const std::string &as) { table_column alias(const std::string &column, const std::string &as) {
return {column, as}; return {column, as};
} }
column alias(column &&col, const std::string &as) { table_column alias(table_column &&col, const std::string &as) {
col.as(as); col.as(as);
return std::move(col); return std::move(col);
} }
column count(const std::string &column) { table_column count(const std::string &column) {
return {sql::sql_function_t::Count, column}; return {sql::sql_function_t::Count, column};
} }
column count_all() { table_column count_all() {
return count("*"); return count("*");
} }
@ -32,16 +32,16 @@ query_select_intermediate query::select() {
return query_select_intermediate{{}}; return query_select_intermediate{{}};
} }
query_select_intermediate query::select( const std::initializer_list<column> columns) { query_select_intermediate query::select( const std::initializer_list<table_column> columns) {
return select(std::vector<column>{columns}); return select(std::vector<table_column>{columns});
} }
query_select_intermediate query::select(const std::vector<column>& columns) { query_select_intermediate query::select(const std::vector<table_column>& columns) {
return query_select_intermediate{columns}; return query_select_intermediate{columns};
} }
query_select_intermediate query::select(const std::vector<std::string> &column_names) { query_select_intermediate query::select(const std::vector<std::string> &column_names) {
std::vector<column> columns; std::vector<table_column> columns;
columns.reserve(column_names.size()); columns.reserve(column_names.size());
for (const auto &col_name : column_names) { for (const auto &col_name : column_names) {
columns.emplace_back(col_name); columns.emplace_back(col_name);
@ -49,7 +49,7 @@ query_select_intermediate query::select(const std::vector<std::string> &column_n
return select(columns); return select(columns);
} }
query_select_intermediate query::select(std::vector<column> columns, const std::initializer_list<column> additional_columns) { query_select_intermediate query::select(std::vector<table_column> columns, const std::initializer_list<table_column> additional_columns) {
for (const auto &col : additional_columns) { for (const auto &col : additional_columns) {
columns.push_back(col); columns.push_back(col);
} }

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

@ -4,8 +4,8 @@
#include "matador/query/query_data.hpp" #include "matador/query/query_data.hpp"
#include "matador/query/criteria_evaluator.hpp" #include "matador/query/criteria_evaluator.hpp"
#include "matador/query/query_utils.hpp" #include "matador/query/query_utils.hpp"
#include "matador/query/constraint.hpp" #include "matador/query/table_constraint.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "matador/query/internal/basic_type_to_string_visitor.hpp" #include "matador/query/internal/basic_type_to_string_visitor.hpp"
#include "matador/query/internal/query_parts.hpp" #include "matador/query/internal/query_parts.hpp"
@ -37,7 +37,7 @@ sql::query_context query_compiler::compile(const query_data &data,
return {query_}; return {query_};
} }
std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const column &col) { std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const table_column &col) {
if (col.is_function()) { if (col.is_function()) {
ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.name()); ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.name());
ctx.prototype.back().change_type(utils::basic_type::Int32); ctx.prototype.back().change_type(utils::basic_type::Int32);
@ -301,8 +301,8 @@ void query_compiler::visit(internal::query_create_part &/*create_part*/)
query_.sql = dialect_->create(); query_.sql = dialect_->create();
} }
std::string build_create_column(const column &col, const sql::dialect &d); std::string build_create_column(const table_column &col, const sql::dialect &d);
std::string build_constraint(const class constraint &cons, const sql::dialect &d); std::string build_constraint(const table_constraint &cons, const sql::dialect &d);
void query_compiler::visit(internal::query_create_table_part &part) void query_compiler::visit(internal::query_create_table_part &part)
{ {
@ -385,7 +385,7 @@ void query_compiler::visit(internal::query_drop_table_part &part) {
query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name); query_.sql += " " + build_table_name(part.token(), *dialect_, query_.table_name);
} }
std::string build_create_column(const column &col, const sql::dialect &d) { std::string build_create_column(const table_column &col, const sql::dialect &d) {
std::string result = d.prepare_identifier_string(col.name()) + " " + d.data_type_at(col.type()); std::string result = d.prepare_identifier_string(col.name()) + " " + d.data_type_at(col.type());
if (col.attributes().size() > 0) { if (col.attributes().size() > 0) {
result.append("(" + std::to_string(col.attributes().size()) + ")"); result.append("(" + std::to_string(col.attributes().size()) + ")");
@ -403,7 +403,7 @@ std::string build_create_column(const column &col, const sql::dialect &d) {
return result; return result;
} }
std::string build_constraint(const constraint& cons, const sql::dialect& d) { std::string build_constraint(const table_constraint& cons, const sql::dialect& d) {
std::string result; std::string result;
if (!cons.name().empty()) { if (!cons.name().empty()) {
result.append(d.constraint()).append(" ").append(cons.name()).append(" "); result.append(d.constraint()).append(" ").append(cons.name()).append(" ");
@ -438,7 +438,7 @@ std::string query_compiler::build_table_name(const sql::dialect_token token, con
(!t.has_alias() ? "" : " " + d.prepare_identifier_string(t.name())); (!t.has_alias() ? "" : " " + d.prepare_identifier_string(t.name()));
} }
std::string query_compiler::build_add_constraint_string(const class constraint &c) const { std::string query_compiler::build_add_constraint_string(const table_constraint &c) const {
std::string result = dialect_->add_constraint() + " " + build_constraint_name(c) + " "; std::string result = dialect_->add_constraint() + " " + build_constraint_name(c) + " ";
if (c.is_primary_key_constraint()) { if (c.is_primary_key_constraint()) {
result.append(dialect_->primary_key()).append(" (").append(c.column_name()).append(")"); result.append(dialect_->primary_key()).append(" (").append(c.column_name()).append(")");
@ -450,11 +450,11 @@ std::string query_compiler::build_add_constraint_string(const class constraint &
return result; return result;
} }
std::string query_compiler::build_drop_constraint_string(const class constraint &c) const { std::string query_compiler::build_drop_constraint_string(const table_constraint &c) const {
return dialect_->drop_constraint() + " " + build_constraint_name(c); return dialect_->drop_constraint() + " " + build_constraint_name(c);
} }
std::string query_compiler::build_constraint_name(const class constraint &c) { std::string query_compiler::build_constraint_name(const table_constraint &c) {
if (c.is_primary_key_constraint()) { if (c.is_primary_key_constraint()) {
return "PK_" + c.table_name(); return "PK_" + c.table_name();
} }

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

@ -3,7 +3,7 @@
#include "matador/query/table.hpp" #include "matador/query/table.hpp"
namespace matador::query { namespace matador::query {
std::string prepare_identifier(const sql::dialect& d, const column& col) { std::string prepare_identifier(const sql::dialect& d, const table_column& col) {
std::string result; std::string result;
if (!col.is_function()) { if (!col.is_function()) {
if (col.table()) { if (col.table()) {
@ -19,7 +19,7 @@ std::string prepare_identifier(const sql::dialect& d, const column& col) {
return result; return result;
} }
std::string prepare_criteria(const sql::dialect& d, const column& col) { std::string prepare_criteria(const sql::dialect& d, const table_column& col) {
std::string result; std::string result;
if (!col.is_function()) { if (!col.is_function()) {
if (col.table()) { if (col.table()) {

2
source/orm/query/schema.cpp
View File

@ -252,7 +252,7 @@ sql::query_context schema::build_drop_constraint_context(const object::repositor
} }
void schema::insert_table(const std::type_index &ti, const object::repository_node &node) { void schema::insert_table(const std::type_index &ti, const object::repository_node &node) {
std::vector<column> columns; std::vector<table_column> columns;
for (const auto &attr: node.info().attributes()) { for (const auto &attr: node.info().attributes()) {
columns.emplace_back(nullptr, attr.name(), attr.type(), attr.attributes()); columns.emplace_back(nullptr, attr.name(), attr.type(), attr.attributes());
} }

14
source/orm/query/table.cpp
View File

@ -11,11 +11,11 @@ table::table(const char* name)
table::table(const std::string& name) table::table(const std::string& name)
: table(name, name, {}) {} : table(name, name, {}) {}
table::table(const std::string& name, const std::vector<column> &columns) table::table(const std::string& name, const std::vector<table_column> &columns)
: table(name, name, columns) { : table(name, name, columns) {
} }
table::table(std::string name, std::string alias, const std::vector<column> &columns) table::table(std::string name, std::string alias, const std::vector<table_column> &columns)
: name_(std::move(name)) : name_(std::move(name))
, alias_(std::move(alias)) , alias_(std::move(alias))
, columns_(columns) { , columns_(columns) {
@ -68,7 +68,7 @@ const std::string& table::name() const {
return alias_; return alias_;
} }
const std::vector<column>& table::columns() const { const std::vector<table_column>& table::columns() const {
return columns_; return columns_;
} }
@ -76,11 +76,11 @@ bool table::has_alias() const {
return name_ != alias_; return name_ != alias_;
} }
table::operator const std::vector<query::column>&() const { table::operator const std::vector<query::table_column>&() const {
return columns_; return columns_;
} }
const class column* table::operator[](const std::string &column_name) const { const table_column* table::operator[](const std::string &column_name) const {
for (const auto &col : columns_) { for (const auto &col : columns_) {
if (col.name() == column_name) { if (col.name() == column_name) {
return &col; return &col;
@ -89,7 +89,7 @@ const class column* table::operator[](const std::string &column_name) const {
return nullptr; return nullptr;
} }
const class column * table::column_by_name(const table &tab, const std::string &column_name) { const table_column * table::column_by_name(const table &tab, const std::string &column_name) {
for (const auto &col : tab.columns_) { for (const auto &col : tab.columns_) {
if (col.name() == column_name) { if (col.name() == column_name) {
return &col; return &col;
@ -98,7 +98,7 @@ const class column * table::column_by_name(const table &tab, const std::string &
return nullptr; return nullptr;
} }
const column& table::create_column(class table &tab, const std::string &name) { const table_column& table::create_column(class table &tab, const std::string &name) {
tab.columns_.emplace_back(name); tab.columns_.emplace_back(name);
tab.columns_.back().table(&tab); tab.columns_.back().table(&tab);
return tab.columns_.back(); return tab.columns_.back();

56
source/orm/query/column.cpp → source/orm/query/table_column.cpp
View File

@ -1,4 +1,4 @@
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "matador/query/table.hpp" #include "matador/query/table.hpp"
@ -7,43 +7,43 @@
namespace matador::query { namespace matador::query {
column operator ""_col(const char *name, const size_t len) { table_column operator ""_col(const char *name, const size_t len) {
const std::string str(name, len); const std::string str(name, len);
const auto pos = str.find('.'); const auto pos = str.find('.');
if (pos == std::string::npos) { if (pos == std::string::npos) {
return column{str}; return table_column{str};
} }
if (str.find('.', pos + 1) != std::string::npos) { if (str.find('.', pos + 1) != std::string::npos) {
throw std::invalid_argument("Invalid column name: multiple dots found"); throw std::invalid_argument("Invalid column name: multiple dots found");
} }
return column{str.substr(pos + 1)}; return table_column{str.substr(pos + 1)};
} }
column::column(const char *name) table_column::table_column(const char *name)
: column(std::string(name)) : table_column(std::string(name))
{} {}
column::column(std::string name) table_column::table_column(std::string name)
: name_(std::move(name)) {} : name_(std::move(name)) {}
column::column(std::string name, std::string alias) table_column::table_column(std::string name, std::string alias)
: name_(std::move(name)) : name_(std::move(name))
, alias_(std::move(alias)) {} , alias_(std::move(alias)) {}
column::column(const sql::sql_function_t func, std::string name) table_column::table_column(const sql::sql_function_t func, std::string name)
: name_(std::move(name)) : name_(std::move(name))
, function_(func) {} , function_(func) {}
column::column(const class table* tab, std::string name) table_column::table_column(const class table* tab, std::string name)
: table_(tab) : table_(tab)
, name_(std::move(name)) {} , name_(std::move(name)) {}
column::column(const class table* tab, std::string name, std::string alias) table_column::table_column(const class table* tab, std::string name, std::string alias)
: table_(tab) : table_(tab)
, name_(std::move(name)) , name_(std::move(name))
, alias_(std::move(alias)) {} , alias_(std::move(alias)) {}
column::column(const class table* tab, table_column::table_column(const class table* tab,
std::string name, std::string name,
const utils::basic_type type, const utils::basic_type type,
const utils::field_attributes& attributes) const utils::field_attributes& attributes)
@ -52,7 +52,7 @@ column::column(const class table* tab,
, type_(type) , type_(type)
, attributes_(attributes) {} , attributes_(attributes) {}
column::column(const class table* tab, table_column::table_column(const class table* tab,
std::string name, std::string name,
std::string alias, std::string alias,
utils::basic_type type, utils::basic_type type,
@ -63,7 +63,7 @@ column::column(const class table* tab,
, type_(type) , type_(type)
, attributes_(attributes) {} , attributes_(attributes) {}
column & column::operator=(const column &other) { table_column & table_column::operator=(const table_column &other) {
if (this == &other) { if (this == &other) {
return *this; return *this;
} }
@ -75,7 +75,7 @@ column & column::operator=(const column &other) {
return *this; return *this;
} }
column::column(const column &other) table_column::table_column(const table_column &other)
: table_(other.table_) : table_(other.table_)
, name_(other.name_) , name_(other.name_)
, alias_(other.alias_) , alias_(other.alias_)
@ -83,7 +83,7 @@ column::column(const column &other)
, attributes_(other.attributes_) { , attributes_(other.attributes_) {
} }
bool column::equals(const column &x) const { bool table_column::equals(const table_column &x) const {
if (table_ != nullptr && x.table_ != nullptr) { if (table_ != nullptr && x.table_ != nullptr) {
return *table_ == *x.table_ && return *table_ == *x.table_ &&
name_ == x.name_ && name_ == x.name_ &&
@ -96,52 +96,52 @@ bool column::equals(const column &x) const {
function_ == x.function_; function_ == x.function_;
} }
column column::as(std::string a) { table_column table_column::as(std::string a) {
alias_ = std::move(a); alias_ = std::move(a);
return {table_, name_, alias_, type_, attributes_}; return {table_, name_, alias_, type_, attributes_};
} }
const std::string& column::name() const { const std::string& table_column::name() const {
return name_; return name_;
} }
const std::string& column::alias() const { const std::string& table_column::alias() const {
return alias_; return alias_;
} }
utils::basic_type column::type() const { utils::basic_type table_column::type() const {
return type_; return type_;
} }
utils::field_attributes column::attributes() const { utils::field_attributes table_column::attributes() const {
return attributes_; return attributes_;
} }
bool column::is_function() const { bool table_column::is_function() const {
return function_ != sql::sql_function_t::None; return function_ != sql::sql_function_t::None;
} }
bool column::is_nullable() const { bool table_column::is_nullable() const {
return !utils::is_constraint_set(attributes_.options(), utils::constraints::NotNull); return !utils::is_constraint_set(attributes_.options(), utils::constraints::NotNull);
} }
sql::sql_function_t column::function() const { sql::sql_function_t table_column::function() const {
return function_; return function_;
} }
bool column::has_alias() const { bool table_column::has_alias() const {
return !alias_.empty(); return !alias_.empty();
} }
const class table* column::table() const { const class table* table_column::table() const {
return table_; return table_;
} }
void column::table(const query::table* tab) { void table_column::table(const query::table* tab) {
table_ = tab; table_ = tab;
} }
column::operator const std::string&() const { table_column::operator const std::string&() const {
return name_; return name_;
} }
} }

26
source/orm/query/constraint.cpp → source/orm/query/table_constraint.cpp
View File

@ -1,21 +1,21 @@
#include "matador/query/constraint.hpp" #include "matador/query/table_constraint.hpp"
#include "matador/utils/constraints.hpp" #include "matador/utils/constraints.hpp"
namespace matador::query { namespace matador::query {
constraint::constraint(std::string column_name, std::string table_name, utils::constraints type) table_constraint::table_constraint(std::string column_name, std::string table_name, utils::constraints type)
: column_name_(std::move(column_name)) : column_name_(std::move(column_name))
, table_name_(std::move(table_name)) , table_name_(std::move(table_name))
, type_(type) {} , type_(type) {}
constraint::constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column) table_constraint::table_constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column)
: column_name_(std::move(column_name)) : column_name_(std::move(column_name))
, table_name_(std::move(table_name)) , table_name_(std::move(table_name))
, type_(type) , type_(type)
, referenced_table_(std::move(referenced_table)) , referenced_table_(std::move(referenced_table))
, referenced_column_(std::move(referenced_column)) {} , referenced_column_(std::move(referenced_column)) {}
constraint::constraint(std::string name, table_constraint::table_constraint(std::string name,
std::string column_name, std::string column_name,
std::string table_name, std::string table_name,
utils::constraints type, utils::constraints type,
@ -28,39 +28,39 @@ constraint::constraint(std::string name,
, referenced_table_(std::move(referenced_table)) , referenced_table_(std::move(referenced_table))
, referenced_column_(std::move(referenced_column)) {} , referenced_column_(std::move(referenced_column)) {}
std::string constraint::name() const { std::string table_constraint::name() const {
return name_; return name_;
} }
std::string constraint::column_name() const { std::string table_constraint::column_name() const {
return column_name_; return column_name_;
} }
std::string constraint::table_name() const { std::string table_constraint::table_name() const {
return table_name_; return table_name_;
} }
const utils::constraints& constraint::type() const { const utils::constraints& table_constraint::type() const {
return type_; return type_;
} }
bool constraint::is_primary_key_constraint() const { bool table_constraint::is_primary_key_constraint() const {
return utils::is_constraint_set(type_, utils::constraints::PrimaryKey); return utils::is_constraint_set(type_, utils::constraints::PrimaryKey);
} }
bool constraint::is_foreign_key_constraint() const { bool table_constraint::is_foreign_key_constraint() const {
return utils::is_constraint_set(type_, utils::constraints::ForeignKey); return utils::is_constraint_set(type_, utils::constraints::ForeignKey);
} }
bool constraint::is_unique_constraint() const { bool table_constraint::is_unique_constraint() const {
return utils::is_constraint_set(type_, utils::constraints::Unique); return utils::is_constraint_set(type_, utils::constraints::Unique);
} }
const std::string& constraint::referenced_table() const { const std::string& table_constraint::referenced_table() const {
return referenced_table_; return referenced_table_;
} }
const std::string& constraint::referenced_column() const { const std::string& table_constraint::referenced_column() const {
return referenced_column_; return referenced_column_;
} }
} }

2
test/backends/QueryRecordTest.cpp
View File

@ -5,7 +5,7 @@
#include "matador/query/builder.hpp" #include "matador/query/builder.hpp"
#include "matador/query/criteria.hpp" #include "matador/query/criteria.hpp"
#include "matador/query/query.hpp" #include "matador/query/query.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "matador/utils/types.hpp" #include "matador/utils/types.hpp"
#include "matador/utils/string.hpp" #include "matador/utils/string.hpp"

2
test/backends/QueryStatementTests.cpp
View File

@ -4,7 +4,7 @@
#include "matador/query/criteria.hpp" #include "matador/query/criteria.hpp"
#include "matador/query/query.hpp" #include "matador/query/query.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "models/person.hpp" #include "models/person.hpp"

46
test/backends/QueryTest.cpp
View File

@ -156,7 +156,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][for
.and_then( [this] { return repo.attach<flight>("flight");} ); .and_then( [this] { return repo.attach<flight>("flight");} );
REQUIRE(result.is_ok()); REQUIRE(result.is_ok());
auto obj = object_generator::generate<airplane>(repo, "airplane"); auto obj = object_generator::generate<airplane>(repo.repo(), "airplane");
auto res = query::create() auto res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -168,7 +168,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][for
REQUIRE(db.exists("airplane")); REQUIRE(db.exists("airplane"));
tables_to_drop.emplace("airplane"); tables_to_drop.emplace("airplane");
obj = object_generator::generate<flight>(repo, "flight"); obj = object_generator::generate<flight>(repo.repo(), "flight");
res = query::create() res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -225,7 +225,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left"
.and_then( [this] { return repo.attach<flight>("flight");} ); .and_then( [this] { return repo.attach<flight>("flight");} );
REQUIRE(result.is_ok()); REQUIRE(result.is_ok());
auto obj = object_generator::generate<airplane>(repo, "airplane"); auto obj = object_generator::generate<airplane>(repo.repo(), "airplane");
auto res = query::create() auto res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -237,7 +237,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left"
REQUIRE(db.exists("airplane")); REQUIRE(db.exists("airplane"));
tables_to_drop.emplace("airplane"); tables_to_drop.emplace("airplane");
obj = object_generator::generate<flight>(repo, "flight"); obj = object_generator::generate<flight>(repo.repo(), "flight");
res = query::create() res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -295,8 +295,8 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left"
REQUIRE(f.value()->at(2).as<std::string>() == "hans"); REQUIRE(f.value()->at(2).as<std::string>() == "hans");
auto select_result = query::select({"f.id", "ap.brand", "ap.model", "f.pilot_name"}) auto select_result = query::select({"f.id", "ap.brand", "ap.model", "f.pilot_name"})
.from({"flight", "f"}) .from("flight"_tab.as("f"))
.join_left({"airplane", "ap"}) .join_left("airplane"_tab.as("ap"))
.on("f.airplane_id"_col == "ap.id"_col) .on("f.airplane_id"_col == "ap.id"_col)
.order_by("f.id").asc() .order_by("f.id").asc()
.fetch_all(db); .fetch_all(db);
@ -321,7 +321,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
.and_then( [this] { return repo.attach<flight>("flight");} ); .and_then( [this] { return repo.attach<flight>("flight");} );
REQUIRE(result.is_ok()); REQUIRE(result.is_ok());
auto obj = object_generator::generate<airplane>(repo, "airplane"); auto obj = object_generator::generate<airplane>(repo.repo(), "airplane");
auto res = query::create() auto res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -333,7 +333,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
REQUIRE(db.exists("airplane")); REQUIRE(db.exists("airplane"));
tables_to_drop.emplace("airplane"); tables_to_drop.emplace("airplane");
obj = object_generator::generate<flight>(repo, "flight"); obj = object_generator::generate<flight>(repo.repo(), "flight");
res = query::create() res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -393,8 +393,8 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
REQUIRE(f.value()->at(2).as<std::string>() == "hans"); REQUIRE(f.value()->at(2).as<std::string>() == "hans");
auto select_result = query::select({"f.id", "f.airplane_id", "ap.brand", "ap.model", "f.pilot_name"}) auto select_result = query::select({"f.id", "f.airplane_id", "ap.brand", "ap.model", "f.pilot_name"})
.from({"flight", "f"}) .from("flight"_tab.as("f"))
.join_left({"airplane", "ap"}) .join_left("airplane"_tab.as("ap"))
.on("f.airplane_id"_col == "ap.id"_col) .on("f.airplane_id"_col == "ap.id"_col)
.where("f.id"_col == 4) .where("f.id"_col == 4)
.fetch_one<flight>(db); .fetch_one<flight>(db);
@ -416,7 +416,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
auto result = repo.attach<recipe>("recipes") auto result = repo.attach<recipe>("recipes")
.and_then( [this] { return repo.attach<ingredient>("ingredients"); } ); .and_then( [this] { return repo.attach<ingredient>("ingredients"); } );
auto obj = object_generator::generate<recipe>(repo, "recipes"); auto obj = object_generator::generate<recipe>(repo.repo(), "recipes");
auto res = query::create() auto res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -428,7 +428,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
REQUIRE(db.exists("recipes")); REQUIRE(db.exists("recipes"));
tables_to_drop.emplace("recipes"); tables_to_drop.emplace("recipes");
obj = object_generator::generate<ingredient>(repo, "ingredients"); obj = object_generator::generate<ingredient>(repo.repo(), "ingredients");
res = query::create() res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -440,7 +440,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
REQUIRE(db.exists("ingredients")); REQUIRE(db.exists("ingredients"));
tables_to_drop.emplace("ingredients"); tables_to_drop.emplace("ingredients");
obj = object_generator::generate<recipe_ingredient>(repo, "recipe_ingredients"); obj = object_generator::generate<recipe_ingredient>(repo.repo(), "recipe_ingredients");
res = query::create() res = query::create()
.table(obj->name()) .table(obj->name())
.columns(obj->attributes()) .columns(obj->attributes())
@ -507,8 +507,8 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
} }
auto select_result = query::select({"r.id", "r.name", "ri.ingredient_id"}) auto select_result = query::select({"r.id", "r.name", "ri.ingredient_id"})
.from({"recipes", "r"}) .from("recipes"_tab.as("r"))
.join_left({"recipe_ingredients", "ri"}) .join_left("recipe_ingredients"_tab.as("ri"))
.on("r.id"_col == "ri.recipe_id"_col) .on("r.id"_col == "ri.recipe_id"_col)
.fetch_all(db); .fetch_all(db);
REQUIRE(select_result.is_ok()); REQUIRE(select_result.is_ok());
@ -533,9 +533,11 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
} }
select_result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"}) select_result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"})
.from({"recipes", "r"}) .from("recipes"_tab.as("r"))
.join_left({"recipe_ingredients", "ri"}).on("r.id"_col == "ri.recipe_id"_col) .join_left("recipe_ingredients"_tab.as("ri"))
.join_left({"ingredients", "i"}).on("ri.ingredient_id"_col == "i.id"_col) .on("r.id"_col == "ri.recipe_id"_col)
.join_left("ingredients"_tab.as("i"))
.on("ri.ingredient_id"_col == "i.id"_col)
.fetch_all(db); .fetch_all(db);
REQUIRE(result.is_ok()); REQUIRE(result.is_ok());
@ -560,9 +562,11 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
} }
select_result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"}) select_result = query::select({"r.id", "r.name", "ri.ingredient_id", "i.name"})
.from({"recipes", "r"}) .from("recipes"_tab.as("r"))
.join_left({"recipe_ingredients", "ri"}).on("r.id"_col == "ri.recipe_id"_col) .join_left("recipe_ingredients"_tab.as("ri"))
.join_left({"ingredients", "i"}).on("ri.ingredient_id"_col == "i.id"_col) .on("r.id"_col == "ri.recipe_id"_col)
.join_left("ingredients"_tab.as("i"))
.on("ri.ingredient_id"_col == "i.id"_col)
.where("r.id"_col == 8) .where("r.id"_col == 8)
.fetch_all(db); .fetch_all(db);
REQUIRE(result.is_ok()); REQUIRE(result.is_ok());

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

@ -8,7 +8,7 @@
#include "matador/query/criteria_evaluator.hpp" #include "matador/query/criteria_evaluator.hpp"
#include "matador/query/query.hpp" #include "matador/query/query.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "matador/query/table.hpp" #include "matador/query/table.hpp"
#include "matador/query/schema.hpp" #include "matador/query/schema.hpp"
@ -59,9 +59,9 @@ public:
, author_id(*column_by_name(*this, "author_id")) { , author_id(*column_by_name(*this, "author_id")) {
} }
const column& id; const table_column& id;
const column& title; const table_column& title;
const column& author_id; const table_column& author_id;
}; };
book_table BOOK; book_table BOOK;
@ -92,7 +92,7 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity
REQUIRE(data->joins.size() == 1); REQUIRE(data->joins.size() == 1);
const auto flights = table("flights").as("t01"); const auto flights = table("flights").as("t01");
const auto airplanes = table("airplanes").as("t02"); const auto airplanes = table("airplanes").as("t02");
const std::vector<column> expected_columns { const std::vector<table_column> expected_columns {
{ &flights, "id", "c01" }, { &flights, "id", "c01" },
{ &airplanes, "id", "c02" }, { &airplanes, "id", "c02" },
{ &airplanes, "brand", "c03" }, { &airplanes, "brand", "c03" },
@ -146,7 +146,7 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
REQUIRE(data->joins.size() == 1); REQUIRE(data->joins.size() == 1);
const auto books = table("books").as("t01"); const auto books = table("books").as("t01");
const auto authors = table("authors").as("t02"); const auto authors = table("authors").as("t02");
const std::vector<column> expected_columns { const std::vector<table_column> expected_columns {
{ &books, "id", "c01" }, { &books, "id", "c01" },
{ &books, "title", "c02" }, { &books, "title", "c02" },
{ &authors, "id", "c03" }, { &authors, "id", "c03" },
@ -218,7 +218,7 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
REQUIRE(data->joins.size() == 1); REQUIRE(data->joins.size() == 1);
const auto orders = table("orders").as("t01"); const auto orders = table("orders").as("t01");
const auto order_details = table("order_details").as("t02"); const auto order_details = table("order_details").as("t02");
const std::vector<column> expected_columns = { const std::vector<table_column> expected_columns = {
{ &orders, "order_id", "c01" }, { &orders, "order_id", "c01" },
{ &orders, "order_date", "c02" }, { &orders, "order_date", "c02" },
{ &orders, "required_date", "c03" }, { &orders, "required_date", "c03" },
@ -282,7 +282,7 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
REQUIRE(data->joins.size() == 2); REQUIRE(data->joins.size() == 2);
const auto ingredients = table("ingredients").as("t01"); const auto ingredients = table("ingredients").as("t01");
const auto recipes = table("recipes").as("t03"); const auto recipes = table("recipes").as("t03");
const std::vector<column> expected_columns { const std::vector<table_column> expected_columns {
{ &ingredients, "id", "c01" }, { &ingredients, "id", "c01" },
{ &ingredients, "name", "c02" }, { &ingredients, "name", "c02" },
{ &recipes, "id", "c03" }, { &recipes, "id", "c03" },
@ -336,7 +336,7 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
REQUIRE(data->joins.size() == 2); REQUIRE(data->joins.size() == 2);
const auto courses = table("courses").as("t01"); const auto courses = table("courses").as("t01");
const auto students = table("students").as("t03"); const auto students = table("students").as("t03");
const std::vector<column> expected_columns { const std::vector<table_column> expected_columns {
{ &courses, "id", "c01" }, { &courses, "id", "c01" },
{ &courses, "title", "c02" }, { &courses, "title", "c02" },
{ &students, "id", "c03" }, { &students, "id", "c03" },
@ -386,7 +386,7 @@ TEST_CASE("Test eager relationship", "[session][eager]") {
.from(*data->root_table) .from(*data->root_table)
.join_left(data->joins) .join_left(data->joins)
.where(std::move(data->where_clause)) .where(std::move(data->where_clause))
.order_by(column{data->root_table, data->pk_column_name}) .order_by(table_column{data->root_table, data->pk_column_name})
.asc() .asc()
.str(db); .str(db);

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

@ -1,7 +1,7 @@
#include <catch2/catch_test_macros.hpp> #include <catch2/catch_test_macros.hpp>
#include "matador/query/generator.hpp" #include "matador/query/generator.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "../../models/airplane.hpp" #include "../../models/airplane.hpp"
#include "../../models/flight.hpp" #include "../../models/flight.hpp"

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

@ -5,7 +5,7 @@
#include <matador/query/criteria.hpp> #include <matador/query/criteria.hpp>
#include <matador/query/query.hpp> #include <matador/query/query.hpp>
#include "matador/query/table.hpp" #include "matador/query/table.hpp"
#include "matador/query/column.hpp" #include "matador/query/table_column.hpp"
#include "matador/query/builder.hpp" #include "matador/query/builder.hpp"
#include "matador/sql/connection.hpp" #include "matador/sql/connection.hpp"
@ -249,8 +249,8 @@ TEST_CASE_METHOD(QueryFixture, "Test create, insert and select a blob column", "
TEST_CASE_METHOD(QueryFixture, "Test select statement with join_left", "[query][statement][join_left]") { TEST_CASE_METHOD(QueryFixture, "Test select statement with join_left", "[query][statement][join_left]") {
const auto ap = table("airplane").as("ap"); const auto ap = table("airplane").as("ap");
const auto f = table("flight").as("f"); const auto f = table("flight").as("f");
const class matador::query::column col1 = {&f, "airplane_id"}; const class matador::query::table_column col1 = {&f, "airplane_id"};
const class matador::query::column col2 = {&ap, "id"}; const class matador::query::table_column col2 = {&ap, "id"};
const auto result = query::select({"f.id", "ap.brand", "f.pilot_name"}) const auto result = query::select({"f.id", "ap.brand", "f.pilot_name"})
.from(table{"flight"}.as("f")) .from(table{"flight"}.as("f"))
.join_left(table{"airplane"}.as("ap")) .join_left(table{"airplane"}.as("ap"))

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

@ -68,7 +68,7 @@ TEST_CASE("Generate columns for object with has many relation", "[column][genera
const auto order_table = table("order"); const auto order_table = table("order");
const auto order_details_table = table("order_details"); const auto order_details_table = table("order_details");
const std::vector<column> expected_columns = { const std::vector<table_column> expected_columns = {
{ &order_table, "order_id", "c01" }, { &order_table, "order_id", "c01" },
{ &order_table, "order_date", "c02" }, { &order_table, "order_date", "c02" },
{ &order_table, "required_date", "c03" }, { &order_table, "required_date", "c03" },
@ -106,7 +106,7 @@ TEST_CASE("Generate columns for object with eager foreign key relation", "[colum
const auto books_table = table("books"); const auto books_table = table("books");
const auto authors_table = table("authors"); const auto authors_table = table("authors");
const std::vector<column> expected_columns { const std::vector<table_column> expected_columns {
{ &books_table, "id", "c01" }, { &books_table, "id", "c01" },
{ &books_table, "title", "c02" }, { &books_table, "title", "c02" },
{ &authors_table, "id", "c03" }, { &authors_table, "id", "c03" },