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

renamed column to table_column and constraint to table_constraint.

Browse Source
This commit is contained in:
sascha
2025-12-31 13:01:54 +01:00
parent ab2d39407c
commit b9d35cbd4e
62 changed files with 424 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/orm/query/builder.cpp
+2 -2
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_};
}
source/orm/query/criteria/abstract_column_criteria.cpp
+2 -2
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_;
}
}
source/orm/query/criteria/between_criteria.cpp
+2 -2
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)
source/orm/query/criteria/binary_criteria.cpp
+4 -4
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_;
}
}
source/orm/query/criteria/collection_criteria.cpp
+4 -4
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)){
source/orm/query/criteria/criteria_operators.cpp
+19 -19
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);
}
}
source/orm/query/criteria/like_criteria.cpp
+2 -2
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)){}
source/orm/query/intermediates/query_alter_table_intermediate.cpp
+7 -7
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_};
}
source/orm/query/intermediates/query_create_intermediate.cpp
+7 -7
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_};
source/orm/query/intermediates/query_execute_where_intermediate.cpp
+1 -1
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_};
}
source/orm/query/intermediates/query_from_intermediate.cpp
+2 -2
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_};
}
source/orm/query/intermediates/query_group_by_intermediate.cpp
+1 -1
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_};
}
source/orm/query/intermediates/query_insert_intermediate.cpp
+4 -4
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);
source/orm/query/intermediates/query_select_intermediate.cpp
+1 -1
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));
}
source/orm/query/intermediates/query_where_intermediate.cpp
+2 -2
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_};
}
source/orm/query/internal/column_value_pair.cpp
+2 -2
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_;
}
source/orm/query/internal/query_parts.cpp
+22 -22
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_;
}
source/orm/query/query.cpp
+9 -9
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);
}
source/orm/query/query_compiler.cpp
+10 -10
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();
}
source/orm/query/query_utils.cpp
+2 -2
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()) {
source/orm/query/schema.cpp
+1 -1
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());
}
source/orm/query/table.cpp
+7 -7
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();
source/orm/query/column.cpp → source/orm/query/table_column.cpp
+28 -28
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_;
}
}
source/orm/query/constraint.cpp → source/orm/query/table_constraint.cpp
+13 -13
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_;
}
}