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( books, BOOK, id, author_id, title, published_in )
QUERY_HELPER( job, JOB, id, payload, type, description, state, mode )
QUERY_HELPER( payload, PAYLOAD, id )
QUERY_HELPER( temporary_table, TEMPORARY_TABLE, id );
QUERY_HELPER(customer, CUSTOMER, id, name, email, address)
QUERY_HELPER(product, PRODUCT, id, title, description, price, category)
QUERY_HELPER(category, CATEGORY, id, title, description)
QUERY_HELPER(cart, CART, id, items, owner)
// 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( job, JOB, id, payload, type, description, state, mode )
//
// QUERY_HELPER( payload, PAYLOAD, id )
//
// QUERY_HELPER( temporary_table, TEMPORARY_TABLE, id );
//
// QUERY_HELPER(customer, CUSTOMER, id, name, email, address)
// QUERY_HELPER(product, PRODUCT, id, title, description, price, category)
// QUERY_HELPER(category, CATEGORY, id, title, description)
// QUERY_HELPER(cart, CART, id, items, owner)
int main() {
using namespace matador::sql;

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

@ -7,6 +7,7 @@
#include "matador/query/criteria.hpp"
#include "matador/query/query.hpp"
#include "matador/query/generator.hpp"
#include "matador/query/schema.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/connection_pool.hpp"
@ -15,7 +16,6 @@
#include "matador/sql/statement_cache.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/object/repository.hpp"
#include <unordered_map>
@ -71,20 +71,13 @@ public:
}
template<class Pointer>
void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {
}
void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many(const char * /*id*/, ContainerType &, const char *join_column, const utils::foreign_attributes &attr) {
}
void on_has_many(const char * /*id*/, ContainerType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &/*cont*/, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr) {
}
void on_has_many_to_many(const char * /*id*/, ContainerType &/*cont*/, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &/*cont*/, const utils::foreign_attributes &attr) {
}
void on_has_many_to_many(const char * /*id*/, ContainerType &/*cont*/, const utils::foreign_attributes &/*attr*/) {}
private:
const std::unordered_map<std::string, sql::statement> &statements_per_column_;
@ -151,7 +144,7 @@ private:
mutable sql::statement_cache cache_;
const sql::dialect &dialect_;
std::unique_ptr<object::repository> schema_;
std::unique_ptr<query::schema> schema_;
mutable std::unordered_map<std::string, std::vector<object::attribute>> prototypes_;
};
@ -167,7 +160,7 @@ utils::result<void, utils::error> session::attach( const std::string& table_name
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::insert(Type *obj) {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (!info) {
return utils::failure(info.err());
}
@ -240,14 +233,14 @@ private:
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::update( const object::object_ptr<Type>& obj ) {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (!info) {
return utils::failure(info.err());
}
using namespace matador::utils;
using namespace matador::query;
const auto col = column(info.value().get().primary_key_attribute()->name());
const auto col = table_column(info.value().get().primary_key_attribute()->name());
auto res = matador::query::query::update(info->get().name())
.set(generator::column_value_pairs<Type>())
.where(col == _)
@ -266,14 +259,14 @@ utils::result<object::object_ptr<Type>, utils::error> session::update( const obj
template<typename Type>
utils::result<void, utils::error> session::remove( const object::object_ptr<Type>& obj ) {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (!info) {
return utils::failure(info.err());
}
using namespace matador::utils;
using namespace matador::query;
const auto col = column(info.value().get().primary_key_attribute()->name());
const auto col = table_column(info.value().get().primary_key_attribute()->name());
auto res = matador::query::query::remove()
.from( info->get().name() )
.where(col == _)
@ -291,22 +284,24 @@ utils::result<void, utils::error> session::remove( const object::object_ptr<Type
template<typename Type, typename PrimaryKeyType>
utils::result<object::object_ptr<Type>, utils::error> session::find(const PrimaryKeyType& pk) {
auto info = schema_->info<Type>();
if (!info) {
const auto it = schema_->find(typeid(Type));
if (it == schema_->end()) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
}
if (!info.value().get().has_primary_key()) {
const auto& info = it->second.node().info();
// if (!info) {
// return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
// }
if (!info.has_primary_key()) {
return utils::failure(make_error(error_code::NoPrimaryKey, "Type hasn't primary key."));
}
const auto& type_info = info.value().get();
session_query_builder eqb(*schema_, *this);
const query::column col(std::make_shared<query::table>(type_info.name()), type_info.primary_key_attribute()->name());
const query::table_column c(&it->second.table(),info.primary_key_attribute()->name());
using namespace matador::query;
auto data = eqb.build<Type>(col == utils::_);
auto data = eqb.build<Type>(c == utils::_);
if (!data.is_ok()) {
return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + type_info.name() + "."));
return utils::failure(make_error(error_code::FailedToBuildQuery, "Failed to build query for type " + info.name() + "."));
}
auto res = build_select_query(data.release()).prepare(*this);
@ -316,14 +311,14 @@ utils::result<object::object_ptr<Type>, utils::error> session::find(const Primar
}
auto stmt_result = res->bind(0, const_cast<PrimaryKeyType&>(pk)).template fetch_one<Type>();
if (stmt_result && !stmt_result.value()) {
return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + type_info.name() + " with primary key " + std::to_string(pk) + "."));
return utils::failure(make_error(error_code::FailedToFindObject, "Failed to find object of type " + info.name() + " with primary key " + std::to_string(pk) + "."));
}
return utils::ok(object::object_ptr<Type>{ stmt_result->release() });
}
template<typename Type>
utils::result<sql::query_result<Type>, utils::error> session::find(query::criteria_ptr clause) {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (!info) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
}
@ -344,7 +339,7 @@ utils::result<sql::query_result<Type>, utils::error> session::find(query::criter
template<typename Type>
utils::result<void, utils::error> session::drop_table() {
auto info = schema_->info<Type>();
auto info = schema_->repo().info<Type>();
if (info) {
return drop_table(info->get().name());
}

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

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

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

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

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

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

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 {
public:
between_criteria() = delete;
between_criteria(const class column& col, int64_t min, int64_t max);
between_criteria(const class column& col, utils::placeholder min, utils::placeholder max);
between_criteria(const table_column& col, int64_t min, int64_t max);
between_criteria(const table_column& col, utils::placeholder min, utils::placeholder max);
void accept(criteria_visitor& visitor) const override;

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -14,7 +14,7 @@ public:
using executable_query::executable_query;
query_execute_limit_intermediate limit(size_t limit);
query_execute_order_by_intermediate order_by(const column &col);
query_execute_order_by_intermediate order_by(const 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)));
// }
query_where_intermediate where(std::unique_ptr<abstract_criteria> &&cond);
query_group_by_intermediate group_by(const column &col);
query_order_by_intermediate order_by(const column &col);
query_group_by_intermediate group_by(const table_column &col);
query_order_by_intermediate order_by(const table_column &col);
private:
query_where_intermediate where_clause(std::unique_ptr<abstract_criteria> &&cond);

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

@ -12,7 +12,7 @@ class query_group_by_intermediate : public fetchable_query
public:
using fetchable_query::fetchable_query;
query_order_by_intermediate order_by(const column &col);
query_order_by_intermediate order_by(const 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) {
return into(tab, generator::columns<Type>(scm));
}
query_into_intermediate into(const table &tab, std::initializer_list<column> columns);
query_into_intermediate into(const table &tab, std::vector<column> &&columns);
query_into_intermediate into(const table &tab, std::initializer_list<table_column> columns);
query_into_intermediate into(const table &tab, std::vector<table_column> &&columns);
query_into_intermediate into(const table &tab, const std::vector<std::string> &column_names);
query_into_intermediate into(const table &tab);
};

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
{
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);
};

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

@ -13,8 +13,8 @@ class query_where_intermediate : public fetchable_query
public:
using fetchable_query::fetchable_query;
query_group_by_intermediate group_by(const column &col);
query_order_by_intermediate order_by(const column &col);
query_group_by_intermediate group_by(const table_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
#define QUERY_KEY_VALUE_PAIR_HPP
#include "matador/query/column.hpp"
#include "matador/query/table_column.hpp"
#include "matador/utils/placeholder.hpp"
#include "matador/utils/types.hpp"
@ -10,7 +10,7 @@ namespace matador::query::internal {
class column_value_pair {
public:
column_value_pair(const column &col, utils::database_type value);
column_value_pair(const table_column &col, utils::database_type value);
column_value_pair(std::string name, utils::database_type value);
column_value_pair(const char *name, utils::database_type value);
column_value_pair(const char *name, utils::placeholder p);
@ -18,11 +18,11 @@ public:
friend bool operator==(const column_value_pair &lhs, const column_value_pair &rhs);
friend bool operator!=(const column_value_pair &lhs, const column_value_pair &rhs);
[[nodiscard]] const column& col() const;
[[nodiscard]] const table_column& col() const;
[[nodiscard]] const std::variant<utils::placeholder, utils::database_type>& value() const;
private:
column column_;
table_column column_;
std::variant<utils::placeholder, utils::database_type> value_;
};

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

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

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

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

@ -22,6 +22,8 @@ namespace internal {
struct basic_type_to_string_visitor;
}
class table_constraint;
struct query_data;
struct value_visitor;
@ -77,9 +79,9 @@ protected:
static std::string build_table_name(sql::dialect_token token, const sql::dialect &d, const table& t);
static std::string determine_value(value_visitor &visitor, const std::variant<utils::placeholder, utils::database_type> &val);
std::string build_add_constraint_string(const class constraint& c) const;
std::string build_drop_constraint_string(const class constraint& c) const;
static std::string build_constraint_name(const class constraint& c);
[[nodiscard]] std::string build_add_constraint_string(const table_constraint& c) const;
[[nodiscard]] std::string build_drop_constraint_string(const table_constraint& c) const;
static std::string build_constraint_name(const table_constraint& c);
protected:
const query_data *data_{};

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

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

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

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

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

@ -15,22 +15,22 @@ namespace matador::query {
class table;
// ReSharper disable CppNonExplicitConvertingConstructor
class column {
class table_column {
public:
column(const char *name); // NOLINT(*-explicit-constructor)
column(std::string name); // NOLINT(*-explicit-constructor)
column(std::string name, std::string alias);
column(sql::sql_function_t func, std::string name);
column(const class table* tab, std::string name);
column(const class table* tab, std::string name, std::string alias);
column(const class table* tab, std::string name, utils::basic_type type, const utils::field_attributes& attributes);
column(const class table*, std::string name, std::string alias, utils::basic_type type, const utils::field_attributes& attributes);
column& operator=(const column& other);
column(const column& other);
table_column(const char *name); // NOLINT(*-explicit-constructor)
table_column(std::string name); // NOLINT(*-explicit-constructor)
table_column(std::string name, std::string alias);
table_column(sql::sql_function_t func, std::string name);
table_column(const class table* tab, std::string name);
table_column(const class table* tab, std::string name, std::string alias);
table_column(const class table* tab, std::string name, utils::basic_type type, const utils::field_attributes& attributes);
table_column(const class table*, std::string name, std::string alias, utils::basic_type type, const utils::field_attributes& attributes);
table_column& operator=(const table_column& other);
table_column(const table_column& other);
[[nodiscard]] bool equals(const column &x) const;
[[nodiscard]] bool equals(const table_column &x) const;
column as(std::string a);
table_column as(std::string a);
[[nodiscard]] const std::string& name() const;
[[nodiscard]] const std::string& alias() const;
@ -60,7 +60,7 @@ private:
sql::sql_function_t function_{sql::sql_function_t::None};
};
column operator ""_col(const char *name, size_t len);
table_column operator ""_col(const char *name, size_t len);
}
#endif //QUERY_COLUMN_HPP

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 {
class constraint {
class table_constraint {
public:
constraint() = default;
constraint(std::string column_name, std::string table_name, utils::constraints type);
constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
constraint(std::string name, std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
table_constraint() = default;
table_constraint(std::string column_name, std::string table_name, utils::constraints type);
table_constraint(std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
table_constraint(std::string name, std::string column_name, std::string table_name, utils::constraints type, std::string referenced_table, std::string referenced_column);
[[nodiscard]] std::string name() const;
[[nodiscard]] std::string column_name() const;

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

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

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/query/attribute_string_writer.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/abstract_column_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/schema.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/sql/abstract_sql_logger.hpp
../../include/matador/sql/backend_provider.hpp
@ -90,8 +90,6 @@ add_library(matador-orm STATIC
orm/session_query_builder.cpp
query/attribute_string_writer.cpp
query/builder.cpp
query/column.cpp
query/constraint.cpp
query/criteria/abstract_column_criteria.cpp
query/criteria/between_criteria.cpp
query/criteria/binary_criteria.cpp
@ -140,6 +138,8 @@ add_library(matador-orm STATIC
query/query_utils.cpp
query/schema.cpp
query/table.cpp
query/table_column.cpp
query/table_constraint.cpp
query/value_extractor.cpp
sql/backend_provider.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)
: cache_(ctx.bus, ctx.pool, ctx.cache_size)
, 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 {
@ -49,7 +49,7 @@ utils::result<void, utils::error> session::create_schema() const {
// }
auto c = cache_.pool().acquire();
for (const auto &node: *schema_) {
for (const auto &node: schema_->repo()) {
auto ctx = query::query::create()
.table(node->name())
.columns(node->info().attributes())
@ -62,7 +62,7 @@ utils::result<void, utils::error> session::create_schema() const {
}
// create table constraints
for (const auto &node: *schema_) {
for (const auto &node: schema_->repo()) {
for (const auto& cons : node->info().constraints()) {
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 {
auto c = cache_.pool().acquire();
// drop table constraints
for (const auto &node: *schema_) {
for (const auto &node: schema_->repo()) {
for (const auto& cons : node->info().constraints()) {
auto ctx = query::query::alter()
.table(node->name())
@ -110,7 +110,7 @@ utils::result<void, utils::error> session::drop_schema() const {
}
// drop table
for (const auto &node: *schema_) {
for (const auto &node: schema_->repo()) {
auto ctx = query::query::drop()
.table(node->name())
.compile(*c);
@ -191,7 +191,7 @@ const class sql::dialect &session::dialect() 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 {

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;
}
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*/) {
@ -73,7 +73,7 @@ std::string session_query_builder::build_alias(const char prefix, const unsigned
return table_info_stack_.size() == 1;
}
void session_query_builder::append_join(const query::column &left, const query::column &right) {
void session_query_builder::append_join(const query::table_column &left, const query::table_column &right) {
using namespace matador::query;
entity_query_data_.joins.push_back({
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)
, size_(size) {}
column_builder::operator class query::column() const {
column_builder::operator class query::table_column() const {
return {nullptr, column_name_, type_, {size_, constraints_}};
}
@ -57,7 +57,7 @@ constraint_builder& constraint_builder::references( std::string table, std::stri
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_};
}

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

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

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

@ -3,13 +3,13 @@
#include "matador/query/criteria/criteria_visitor.hpp"
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)
, min_(utils::value{min})
, 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)
, min_(min)
, max_(max)

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

@ -3,7 +3,7 @@
#include "matador/query/criteria/criteria_visitor.hpp"
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)
, operator_(operand)
, value_(std::move(value))
@ -21,7 +21,7 @@ const criteria_value& binary_criteria::value() const {
return value_;
}
binary_column_criteria::binary_column_criteria(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)
, operator_(operand)
, right_column_(right_column){}
@ -30,7 +30,7 @@ void binary_column_criteria::accept(criteria_visitor& visitor) const {
visitor.visit(*this);
}
const class column& binary_column_criteria::left_column() const {
const table_column& binary_column_criteria::left_column() const {
return left_column_;
}
@ -38,7 +38,7 @@ binary_operator binary_column_criteria::operand() const {
return operator_;
}
const class column& binary_column_criteria::right_column() const {
const table_column& binary_column_criteria::right_column() const {
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/criteria_visitor.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table_column.hpp"
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)
, operand_(operand_)
, 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)
, operand_(operand_)
, values_(values)
@ -28,7 +28,7 @@ const std::vector<criteria_value>& collection_criteria::values() const {
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)
, operand_(operand_)
, query_context_(std::move(ctx)){

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

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

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/constraint.hpp"
#include "matador/query/table_constraint.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));
}
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));
}
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));
return {context_};
}
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) {
if (restr.is_primary_key_constraint()) {
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) {
std::list<column> columns;
std::list<table_column> columns;
for (const auto& attr : attributes) {
auto options = attr.attributes().options();
if (!attr.is_nullable()) {
@ -70,11 +70,11 @@ query_create_table_columns_intermediate query_create_table_intermediate::columns
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));
}
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));
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_};
}
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));
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_};
}
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));
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));
return {context_};
}

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

@ -5,7 +5,7 @@
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));
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>());
}
query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list<column> columns) {
return into(tab, std::move(std::vector<column>{columns}));
query_into_intermediate query_insert_intermediate::into(const table &tab, const std::initializer_list<table_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));
return {context_};
}
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());
for (const auto &col_name : column_names) {
columns.emplace_back(col_name);

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

@ -6,7 +6,7 @@
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));
}

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

@ -6,12 +6,12 @@
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));
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));
return {context_};
}

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

@ -9,7 +9,7 @@ column_value_pair::column_value_pair(std::string name, utils::database_type valu
, value_(std::move(value)) {
}
column_value_pair::column_value_pair(const column &col, utils::database_type value)
column_value_pair::column_value_pair(const table_column &col, utils::database_type value)
: column_(col)
, value_(std::move(value)) {
}
@ -23,7 +23,7 @@ column_value_pair::column_value_pair( const char* name, utils::placeholder p )
: column_(name)
, value_(p) {}
const column &column_value_pair::col() const {
const table_column &column_value_pair::col() const {
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_;
}
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)
, constraint_(co) {}
@ -42,7 +42,7 @@ void query_add_constraint_part_by_constraint::accept(query_part_visitor &visitor
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_;
}
@ -58,7 +58,7 @@ const std::string& query_drop_key_constraint_part_by_name::name() const {
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 )
, constraint_(co) {}
@ -66,11 +66,11 @@ void query_drop_key_constraint_part_by_constraint::accept(query_part_visitor& vi
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_;
}
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)
, columns_(columns) {}
@ -78,11 +78,11 @@ void query_add_foreign_key_constraint_part::accept( query_part_visitor& visitor
visitor.visit(*this);
}
const std::vector<column>& query_add_foreign_key_constraint_part::columns() const {
const std::vector<table_column>& query_add_foreign_key_constraint_part::columns() const {
return columns_;
}
query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<column>& columns)
query_add_foreign_key_reference_part::query_add_foreign_key_reference_part(class table tab, const std::vector<table_column>& columns)
: query_part(sql::dialect_token::References)
, table_(std::move(tab))
, columns_(columns) {}
@ -95,11 +95,11 @@ const table& query_add_foreign_key_reference_part::table() const {
return table_;
}
const std::vector<column>& query_add_foreign_key_reference_part::columns() const {
const std::vector<table_column>& query_add_foreign_key_reference_part::columns() const {
return columns_;
}
query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<column>& columns)
query_add_primary_key_constraint_part::query_add_primary_key_constraint_part(const std::vector<table_column>& columns)
: query_part(sql::dialect_token::PrimaryKey)
, columns_(columns) {}
@ -107,11 +107,11 @@ void query_add_primary_key_constraint_part::accept( query_part_visitor& visitor
visitor.visit(*this);
}
const std::vector<column>& query_add_primary_key_constraint_part::columns() const {
const std::vector<table_column>& query_add_primary_key_constraint_part::columns() const {
return columns_;
}
query_select_part::query_select_part(std::vector<column> columns)
query_select_part::query_select_part(std::vector<table_column> columns)
: query_part(sql::dialect_token::Select)
, columns_(std::move(columns)) {}
@ -120,7 +120,7 @@ void query_select_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
const std::vector<column>& query_select_part::columns() const
const std::vector<table_column>& query_select_part::columns() const
{
return columns_;
}
@ -185,12 +185,12 @@ query_table_name_part::query_table_name_part(const sql::dialect_token token, std
: query_part(token)
, table_name_(std::move(table_name)) {}
query_group_by_part::query_group_by_part(class column col)
query_group_by_part::query_group_by_part(class table_column col)
: query_part(sql::dialect_token::GroupBy)
, column_(std::move(col))
{}
const column &query_group_by_part::column() const
const table_column &query_group_by_part::column() const
{
return column_;
}
@ -200,12 +200,12 @@ void query_group_by_part::accept(query_part_visitor &visitor)
visitor.visit(*this);
}
query_order_by_part::query_order_by_part(class column col)
query_order_by_part::query_order_by_part(class table_column col)
: query_part(sql::dialect_token::OrderBy)
, column_(std::move(col))
{}
const column &query_order_by_part::column() const
const table_column &query_order_by_part::column() const
{
return column_;
}
@ -269,7 +269,7 @@ void query_insert_part::accept(query_part_visitor &visitor)
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)
, table_(std::move(tab))
, columns_(std::move(columns)) {}
@ -279,7 +279,7 @@ const table &query_into_part::table() const
return table_;
}
const std::vector<column> &query_into_part::columns() const
const std::vector<table_column> &query_into_part::columns() const
{
return columns_;
}
@ -375,11 +375,11 @@ void query_create_table_part::accept(query_part_visitor &visitor)
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 )
, 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_;
}
@ -387,11 +387,11 @@ void query_create_table_columns_part::accept(query_part_visitor& visitor) {
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 )
, 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_;
}

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

@ -2,20 +2,20 @@
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};
}
column alias(column &&col, const std::string &as) {
table_column alias(table_column &&col, const std::string &as) {
col.as(as);
return std::move(col);
}
column count(const std::string &column) {
table_column count(const std::string &column) {
return {sql::sql_function_t::Count, column};
}
column count_all() {
table_column count_all() {
return count("*");
}
@ -32,16 +32,16 @@ query_select_intermediate query::select() {
return query_select_intermediate{{}};
}
query_select_intermediate query::select( const std::initializer_list<column> columns) {
return select(std::vector<column>{columns});
query_select_intermediate query::select( const std::initializer_list<table_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};
}
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());
for (const auto &col_name : column_names) {
columns.emplace_back(col_name);
@ -49,7 +49,7 @@ query_select_intermediate query::select(const std::vector<std::string> &column_n
return select(columns);
}
query_select_intermediate query::select(std::vector<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) {
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/criteria_evaluator.hpp"
#include "matador/query/query_utils.hpp"
#include "matador/query/constraint.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table_constraint.hpp"
#include "matador/query/table_column.hpp"
#include "matador/query/internal/basic_type_to_string_visitor.hpp"
#include "matador/query/internal/query_parts.hpp"
@ -37,7 +37,7 @@ sql::query_context query_compiler::compile(const query_data &data,
return {query_};
}
std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const column &col) {
std::string handle_column(sql::query_context &ctx, const sql::dialect *d, const query_data &data, const table_column &col) {
if (col.is_function()) {
ctx.prototype.emplace_back(col.has_alias() ? col.alias() : col.name());
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();
}
std::string build_create_column(const column &col, const sql::dialect &d);
std::string build_constraint(const class constraint &cons, const sql::dialect &d);
std::string build_create_column(const table_column &col, 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)
{
@ -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);
}
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());
if (col.attributes().size() > 0) {
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;
}
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;
if (!cons.name().empty()) {
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()));
}
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) + " ";
if (c.is_primary_key_constraint()) {
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;
}
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);
}
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()) {
return "PK_" + c.table_name();
}

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

@ -3,7 +3,7 @@
#include "matador/query/table.hpp"
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;
if (!col.is_function()) {
if (col.table()) {
@ -19,7 +19,7 @@ std::string prepare_identifier(const sql::dialect& d, const column& col) {
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;
if (!col.is_function()) {
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) {
std::vector<column> columns;
std::vector<table_column> columns;
for (const auto &attr: node.info().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(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::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))
, alias_(std::move(alias))
, columns_(columns) {
@ -68,7 +68,7 @@ const std::string& table::name() const {
return alias_;
}
const std::vector<column>& table::columns() const {
const std::vector<table_column>& table::columns() const {
return columns_;
}
@ -76,11 +76,11 @@ bool table::has_alias() const {
return name_ != alias_;
}
table::operator const std::vector<query::column>&() const {
table::operator const std::vector<query::table_column>&() const {
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_) {
if (col.name() == column_name) {
return &col;
@ -89,7 +89,7 @@ const class column* table::operator[](const std::string &column_name) const {
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_) {
if (col.name() == column_name) {
return &col;
@ -98,7 +98,7 @@ const class column * table::column_by_name(const table &tab, const std::string &
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_.back().table(&tab);
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"
@ -7,43 +7,43 @@
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 auto pos = str.find('.');
if (pos == std::string::npos) {
return column{str};
return table_column{str};
}
if (str.find('.', pos + 1) != std::string::npos) {
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)
: column(std::string(name))
table_column::table_column(const char *name)
: table_column(std::string(name))
{}
column::column(std::string name)
table_column::table_column(std::string 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))
, 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))
, function_(func) {}
column::column(const class table* tab, std::string name)
table_column::table_column(const class table* tab, std::string name)
: table_(tab)
, 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)
, name_(std::move(name))
, alias_(std::move(alias)) {}
column::column(const class table* tab,
table_column::table_column(const class table* tab,
std::string name,
const utils::basic_type type,
const utils::field_attributes& attributes)
@ -52,7 +52,7 @@ column::column(const class table* tab,
, type_(type)
, attributes_(attributes) {}
column::column(const class table* tab,
table_column::table_column(const class table* tab,
std::string name,
std::string alias,
utils::basic_type type,
@ -63,7 +63,7 @@ column::column(const class table* tab,
, type_(type)
, attributes_(attributes) {}
column & column::operator=(const column &other) {
table_column & table_column::operator=(const table_column &other) {
if (this == &other) {
return *this;
}
@ -75,7 +75,7 @@ column & column::operator=(const column &other) {
return *this;
}
column::column(const column &other)
table_column::table_column(const table_column &other)
: table_(other.table_)
, name_(other.name_)
, alias_(other.alias_)
@ -83,7 +83,7 @@ column::column(const column &other)
, 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) {
return *table_ == *x.table_ &&
name_ == x.name_ &&
@ -96,52 +96,52 @@ bool column::equals(const column &x) const {
function_ == x.function_;
}
column column::as(std::string a) {
table_column table_column::as(std::string a) {
alias_ = std::move(a);
return {table_, name_, alias_, type_, attributes_};
}
const std::string& column::name() const {
const std::string& table_column::name() const {
return name_;
}
const std::string& column::alias() const {
const std::string& table_column::alias() const {
return alias_;
}
utils::basic_type column::type() const {
utils::basic_type table_column::type() const {
return type_;
}
utils::field_attributes column::attributes() const {
utils::field_attributes table_column::attributes() const {
return attributes_;
}
bool column::is_function() const {
bool table_column::is_function() const {
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);
}
sql::sql_function_t column::function() const {
sql::sql_function_t table_column::function() const {
return function_;
}
bool column::has_alias() const {
bool table_column::has_alias() const {
return !alias_.empty();
}
const class table* column::table() const {
const class table* table_column::table() const {
return table_;
}
void column::table(const query::table* tab) {
void table_column::table(const query::table* tab) {
table_ = tab;
}
column::operator const std::string&() const {
table_column::operator const std::string&() const {
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"
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))
, table_name_(std::move(table_name))
, 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))
, table_name_(std::move(table_name))
, type_(type)
, referenced_table_(std::move(referenced_table))
, referenced_column_(std::move(referenced_column)) {}
constraint::constraint(std::string name,
table_constraint::table_constraint(std::string name,
std::string column_name,
std::string table_name,
utils::constraints type,
@ -28,39 +28,39 @@ constraint::constraint(std::string name,
, referenced_table_(std::move(referenced_table))
, referenced_column_(std::move(referenced_column)) {}
std::string constraint::name() const {
std::string table_constraint::name() const {
return name_;
}
std::string constraint::column_name() const {
std::string table_constraint::column_name() const {
return column_name_;
}
std::string constraint::table_name() const {
std::string table_constraint::table_name() const {
return table_name_;
}
const utils::constraints& constraint::type() const {
const utils::constraints& table_constraint::type() const {
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);
}
bool constraint::is_foreign_key_constraint() const {
bool table_constraint::is_foreign_key_constraint() const {
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);
}
const std::string& constraint::referenced_table() const {
const std::string& table_constraint::referenced_table() const {
return referenced_table_;
}
const std::string& constraint::referenced_column() const {
const std::string& table_constraint::referenced_column() const {
return referenced_column_;
}
}

2
test/backends/QueryRecordTest.cpp
View File

@ -5,7 +5,7 @@
#include "matador/query/builder.hpp"
#include "matador/query/criteria.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/string.hpp"

2
test/backends/QueryStatementTests.cpp
View File

@ -4,7 +4,7 @@
#include "matador/query/criteria.hpp"
#include "matador/query/query.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table_column.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");} );
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()
.table(obj->name())
.columns(obj->attributes())
@ -168,7 +168,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key", "[query][for
REQUIRE(db.exists("airplane"));
tables_to_drop.emplace("airplane");
obj = object_generator::generate<flight>(repo, "flight");
obj = object_generator::generate<flight>(repo.repo(), "flight");
res = query::create()
.table(obj->name())
.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");} );
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()
.table(obj->name())
.columns(obj->attributes())
@ -237,7 +237,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and join_left"
REQUIRE(db.exists("airplane"));
tables_to_drop.emplace("airplane");
obj = object_generator::generate<flight>(repo, "flight");
obj = object_generator::generate<flight>(repo.repo(), "flight");
res = query::create()
.table(obj->name())
.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");
auto select_result = query::select({"f.id", "ap.brand", "ap.model", "f.pilot_name"})
.from({"flight", "f"})
.join_left({"airplane", "ap"})
.from("flight"_tab.as("f"))
.join_left("airplane"_tab.as("ap"))
.on("f.airplane_id"_col == "ap.id"_col)
.order_by("f.id").asc()
.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");} );
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()
.table(obj->name())
.columns(obj->attributes())
@ -333,7 +333,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with foreign key and for single
REQUIRE(db.exists("airplane"));
tables_to_drop.emplace("airplane");
obj = object_generator::generate<flight>(repo, "flight");
obj = object_generator::generate<flight>(repo.repo(), "flight");
res = query::create()
.table(obj->name())
.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");
auto select_result = query::select({"f.id", "f.airplane_id", "ap.brand", "ap.model", "f.pilot_name"})
.from({"flight", "f"})
.join_left({"airplane", "ap"})
.from("flight"_tab.as("f"))
.join_left("airplane"_tab.as("ap"))
.on("f.airplane_id"_col == "ap.id"_col)
.where("f.id"_col == 4)
.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")
.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()
.table(obj->name())
.columns(obj->attributes())
@ -428,7 +428,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
REQUIRE(db.exists("recipes"));
tables_to_drop.emplace("recipes");
obj = object_generator::generate<ingredient>(repo, "ingredients");
obj = object_generator::generate<ingredient>(repo.repo(), "ingredients");
res = query::create()
.table(obj->name())
.columns(obj->attributes())
@ -440,7 +440,7 @@ TEST_CASE_METHOD(QueryFixture, "Select statement with many to many relationship"
REQUIRE(db.exists("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()
.table(obj->name())
.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"})
.from({"recipes", "r"})
.join_left({"recipe_ingredients", "ri"})
.from("recipes"_tab.as("r"))
.join_left("recipe_ingredients"_tab.as("ri"))
.on("r.id"_col == "ri.recipe_id"_col)
.fetch_all(db);
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"})
.from({"recipes", "r"})
.join_left({"recipe_ingredients", "ri"}).on("r.id"_col == "ri.recipe_id"_col)
.join_left({"ingredients", "i"}).on("ri.ingredient_id"_col == "i.id"_col)
.from("recipes"_tab.as("r"))
.join_left("recipe_ingredients"_tab.as("ri"))
.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);
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"})
.from({"recipes", "r"})
.join_left({"recipe_ingredients", "ri"}).on("r.id"_col == "ri.recipe_id"_col)
.join_left({"ingredients", "i"}).on("ri.ingredient_id"_col == "i.id"_col)
.from("recipes"_tab.as("r"))
.join_left("recipe_ingredients"_tab.as("ri"))
.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)
.fetch_all(db);
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/query.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table_column.hpp"
#include "matador/query/table.hpp"
#include "matador/query/schema.hpp"
@ -59,9 +59,9 @@ public:
, author_id(*column_by_name(*this, "author_id")) {
}
const column& id;
const column& title;
const column& author_id;
const table_column& id;
const table_column& title;
const table_column& author_id;
};
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);
const auto flights = table("flights").as("t01");
const auto airplanes = table("airplanes").as("t02");
const std::vector<column> expected_columns {
const std::vector<table_column> expected_columns {
{ &flights, "id", "c01" },
{ &airplanes, "id", "c02" },
{ &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);
const auto books = table("books").as("t01");
const auto authors = table("authors").as("t02");
const std::vector<column> expected_columns {
const std::vector<table_column> expected_columns {
{ &books, "id", "c01" },
{ &books, "title", "c02" },
{ &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);
const auto orders = table("orders").as("t01");
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_date", "c02" },
{ &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);
const auto ingredients = table("ingredients").as("t01");
const auto recipes = table("recipes").as("t03");
const std::vector<column> expected_columns {
const std::vector<table_column> expected_columns {
{ &ingredients, "id", "c01" },
{ &ingredients, "name", "c02" },
{ &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);
const auto courses = table("courses").as("t01");
const auto students = table("students").as("t03");
const std::vector<column> expected_columns {
const std::vector<table_column> expected_columns {
{ &courses, "id", "c01" },
{ &courses, "title", "c02" },
{ &students, "id", "c03" },
@ -386,7 +386,7 @@ TEST_CASE("Test eager relationship", "[session][eager]") {
.from(*data->root_table)
.join_left(data->joins)
.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()
.str(db);

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

@ -1,7 +1,7 @@
#include <catch2/catch_test_macros.hpp>
#include "matador/query/generator.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table_column.hpp"
#include "../../models/airplane.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/query.hpp>
#include "matador/query/table.hpp"
#include "matador/query/column.hpp"
#include "matador/query/table_column.hpp"
#include "matador/query/builder.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]") {
const auto ap = table("airplane").as("ap");
const auto f = table("flight").as("f");
const class matador::query::column col1 = {&f, "airplane_id"};
const class matador::query::column col2 = {&ap, "id"};
const class matador::query::table_column col1 = {&f, "airplane_id"};
const class matador::query::table_column col2 = {&ap, "id"};
const auto result = query::select({"f.id", "ap.brand", "f.pilot_name"})
.from(table{"flight"}.as("f"))
.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_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_date", "c02" },
{ &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 authors_table = table("authors");
const std::vector<column> expected_columns {
const std::vector<table_column> expected_columns {
{ &books_table, "id", "c01" },
{ &books_table, "title", "c02" },
{ &authors_table, "id", "c03" },