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

column_expression progress

This commit is contained in:
sascha 2026-03-05 16:10:02 +01:00
parent d9eaa2009f
commit bc8158a6ca
12 changed files with 71 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -256,9 +256,9 @@ public:
template<typename Type> template<typename Type>
void push_back(const char* id, const Type& value) { void push_back(const char* id, const Type& value) {
if (is_column_value_generator_option_set(options_, column_value_generator_options::ValuesAsPlaceHolder)) { if (is_column_value_generator_option_set(options_, column_value_generator_options::ValuesAsPlaceHolder)) {
result_.emplace_back(id, utils::_); result_.emplace_back(id, std::make_unique<placeholder_expression>());
} else { } else {
result_.emplace_back(id, value); result_.emplace_back(id, std::make_unique<value_expression>(value));
} }
} }

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

@ -11,21 +11,22 @@ namespace matador::query::internal {
class column_value_pair { class column_value_pair {
public: public:
column_value_pair(table_column col, utils::database_type value); // column_value_pair(table_column col, utils::database_type value);
column_value_pair(const std::string& name, utils::database_type value); // column_value_pair(const std::string& name, utils::database_type value);
column_value_pair(const char *name, utils::database_type value); // column_value_pair(const char *name, utils::database_type value);
column_value_pair(const char *name, utils::placeholder p); // column_value_pair(const char *name, utils::placeholder p);
column_value_pair(table_column col, column_expression_ptr expression); column_value_pair(table_column col, column_expression_ptr expression);
friend bool operator==(const column_value_pair &lhs, const column_value_pair &rhs); friend bool operator==(const column_value_pair &lhs, const column_value_pair &rhs);
friend bool operator!=(const column_value_pair &lhs, const column_value_pair &rhs); friend bool operator!=(const column_value_pair &lhs, const column_value_pair &rhs);
[[nodiscard]] const table_column& col() const; [[nodiscard]] const table_column& col() const;
[[nodiscard]] const std::variant<utils::placeholder, utils::database_type>& value() const; // [[nodiscard]] const std::variant<utils::placeholder, utils::database_type>& value() const;
[[nodiscard]] const abstract_column_expression& expression() const;
private: private:
table_column column_; table_column column_;
std::variant<utils::placeholder, utils::database_type> value_; // std::variant<utils::placeholder, utils::database_type> value_;
column_expression_ptr expression_; column_expression_ptr expression_;
}; };

2
include/matador/query/key_value_generator.hpp
View File

@ -30,7 +30,7 @@ public:
void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) { void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
result_.emplace_back(id, x); result_.emplace_back(id, x);
} }
void on_revision(const char *id, uint64_t &/*rev*/); void on_revision(const char *id, uint64_t &/*rev*/) const;
template<typename Type> template<typename Type>
void on_attribute(const char *id, Type &x, const utils::field_attributes &/*attr*/ = utils::null_attributes) { void on_attribute(const char *id, Type &x, const utils::field_attributes &/*attr*/ = utils::null_attributes) {

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

@ -22,18 +22,18 @@ public:
table_column(const std::string& name, const std::string& alias); table_column(const std::string& name, const std::string& alias);
table_column(sql::sql_function_t func, const std::string& name); table_column(sql::sql_function_t func, const std::string& name);
table_column(const class table* tab, const std::string& name); table_column(const class table* tab, const std::string& name);
table_column(const class table* tab, const std::string& name, table_column(const class table* tab, const std::string& name, const std::string& alias);
const std::string& alias);
table_column(const class table* tab, const std::string& name, utils::basic_type type, const utils::field_attributes& attributes); table_column(const class table* tab, const std::string& name, utils::basic_type type, const utils::field_attributes& attributes);
table_column(const class table*, table_column(const class table*,
const std::string& name, const std::string& name,
std::string alias, std::string alias,
utils::basic_type type, utils::basic_type type,
const utils::field_attributes& attributes, const utils::field_attributes& attributes,
sql::sql_function_t func = sql::sql_function_t::None); sql::sql_function_t func = sql::sql_function_t::None,
const std::shared_ptr<abstract_column_expression>& expression = {});
table_column(column_expression_ptr expression) noexcept; table_column(const std::shared_ptr<abstract_column_expression>& expression) noexcept;
table_column& operator=(const table_column& other); table_column& operator=(const table_column& other);
table_column(const table_column& other) = default; table_column(const table_column& other) = default;
table_column(table_column&& other) noexcept = default; table_column(table_column&& other) noexcept = default;
@ -96,7 +96,7 @@ public:
// New: expression-backed column support // New: expression-backed column support
[[nodiscard]] bool is_expression() const; [[nodiscard]] bool is_expression() const;
[[nodiscard]] const column_expression_ptr& expression() const; [[nodiscard]] std::shared_ptr<abstract_column_expression> expression() const;
// ReSharper disable once CppNonExplicitConversionOperator // ReSharper disable once CppNonExplicitConversionOperator
operator const std::string&() const; // NOLINT(*-explicit-constructor) operator const std::string&() const; // NOLINT(*-explicit-constructor)
@ -116,7 +116,7 @@ private:
sql::sql_function_t function_{sql::sql_function_t::None}; sql::sql_function_t function_{sql::sql_function_t::None};
column_expression_ptr expression_{}; std::shared_ptr<abstract_column_expression> expression_;
}; };
table_column operator ""_col(const char *name, size_t len); table_column operator ""_col(const char *name, size_t len);

2
source/orm/query/expression/column_expression.cpp
View File

@ -25,7 +25,7 @@ column_expression::operator std::unique_ptr<abstract_column_expression>() && noe
} }
table_column column_expression::as(const std::string& alias) && { table_column column_expression::as(const std::string& alias) && {
const table_column col{std::move(expression_)}; const table_column col{std::shared_ptr<abstract_column_expression>(expression_.release())};
return col.as(alias); return col.as(alias);
} }
} }

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

@ -4,24 +4,24 @@
namespace matador::query::internal { namespace matador::query::internal {
column_value_pair::column_value_pair(const std::string& name, utils::database_type value) // column_value_pair::column_value_pair(const std::string& name, utils::database_type value)
: column_(name) // : column_(name)
, value_(std::move(value)) { // , value_(std::move(value)) {
} // }
//
column_value_pair::column_value_pair(table_column col, utils::database_type value) // column_value_pair::column_value_pair(table_column col, utils::database_type value)
: column_(std::move(col)) // : column_(std::move(col))
, value_(std::move(value)) { // , value_(std::move(value)) {
} // }
//
column_value_pair::column_value_pair(const char *name, utils::database_type value) // column_value_pair::column_value_pair(const char *name, utils::database_type value)
: column_(name) // : column_(name)
, value_(std::move(value)) { // , value_(std::move(value)) {
} // }
//
column_value_pair::column_value_pair( const char* name, utils::placeholder p ) // column_value_pair::column_value_pair( const char* name, utils::placeholder p )
: column_(name) // : column_(name)
, value_(p) {} // , value_(p) {}
column_value_pair::column_value_pair(table_column col, column_expression_ptr expression) column_value_pair::column_value_pair(table_column col, column_expression_ptr expression)
: column_(std::move(col)) : column_(std::move(col))
@ -32,12 +32,16 @@ const table_column &column_value_pair::col() const {
return column_; return column_;
} }
const std::variant<utils::placeholder, utils::database_type>& column_value_pair::value() const { // const std::variant<utils::placeholder, utils::database_type>& column_value_pair::value() const {
return value_; // return value_;
// }
const abstract_column_expression& column_value_pair::expression() const {
return *expression_;
} }
bool operator==( const column_value_pair& lhs, const column_value_pair& rhs ) { bool operator==( const column_value_pair& lhs, const column_value_pair& rhs ) {
return lhs.column_.equals(rhs.column_) && lhs.value_ == rhs.value_; return lhs.column_.equals(rhs.column_) && lhs.expression_ == rhs.expression_;
} }
bool operator!=( const column_value_pair& lhs, const column_value_pair& rhs ) { bool operator!=( const column_value_pair& lhs, const column_value_pair& rhs ) {

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

@ -6,8 +6,8 @@ namespace matador::query {
key_value_generator::key_value_generator(std::vector<internal::column_value_pair> &result) key_value_generator::key_value_generator(std::vector<internal::column_value_pair> &result)
: result_(result) {} : result_(result) {}
void key_value_generator::on_revision(const char *id, uint64_t &x) { void key_value_generator::on_revision(const char *id, uint64_t &x) const {
result_.emplace_back(id, x); result_.emplace_back(id, std::make_unique<value_expression>(x));
} }
} }

6
source/orm/query/query_builder.cpp
View File

@ -91,8 +91,12 @@ void query_builder::visit(internal::query_select_part &part) {
query_.prototype.clear(); query_.prototype.clear();
if (part.columns().empty()) {
query_.sql += dialect_->asterisk();
} else {
build_fetchable_columns(query_, part.columns(), *dialect_); build_fetchable_columns(query_, part.columns(), *dialect_);
} }
}
void query_builder::visit(internal::query_select_nextval_part& part) { void query_builder::visit(internal::query_select_nextval_part& part) {
query_.sql += dialect_->nextval() + "('" + part.sequence_name() + "')"; query_.sql += dialect_->nextval() + "('" + part.sequence_name() + "')";
@ -410,7 +414,7 @@ void build_fetchable_columns(sql::query_context &ctx, const std::vector<table_co
ctx.sql.append(", "); ctx.sql.append(", ");
} }
prepare_prototype(ctx.prototype, col); prepare_prototype(ctx.prototype, col);
prepare_column(ctx.sql, d, col); prepare_column(ctx, d, col);
first = false; first = false;
} }
} }

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

@ -12,25 +12,15 @@ namespace matador::query {
void prepare_column(sql::query_context& ctx, const sql::dialect& d, const table_column& col) { void prepare_column(sql::query_context& ctx, const sql::dialect& d, const table_column& col) {
// Expression-backed select item: (<expr>) [AS alias] // Expression-backed select item: (<expr>) [AS alias]
if (col.is_expression()) { if (col.is_expression()) {
// attribute_string_writer writer(d); attribute_string_writer writer(d, {});
expression_evaluator v(d, ctx); expression_evaluator v(d, ctx);
col.expression()->accept(v); col.expression()->accept(v);
if (col.has_alias()) { if (col.has_alias()) {
ctx.sql.append(" ").append(d.as()).append(" ").append(col.alias()); ctx.sql.append(" ").append(d.as()).append(" ").append(col.alias());
} }
return;
}
// Existing behavior: plain column or function
if (!col.is_function()) {
prepare_identifier_string_append(ctx.sql, col.name(), d);
} else { } else {
if (col.column_name() == d.asterisk()) { prepare_column(ctx.sql, d, col);
ctx.sql += d.sql_function_at(col.function()) + "(" + col.column_name() + ")";
} else {
ctx.sql += d.sql_function_at(col.function()) + "(" + col.column_name() + ") " + d.as() + " " + col.alias();
}
} }
} }

11
source/orm/query/table_column.cpp
View File

@ -53,14 +53,19 @@ table_column::table_column(const class table* tab,
std::string alias, std::string alias,
const utils::basic_type type, const utils::basic_type type,
const utils::field_attributes &attributes, const utils::field_attributes &attributes,
const sql::sql_function_t func) const sql::sql_function_t func,
const std::shared_ptr<abstract_column_expression>& expression)
: table_(tab) : table_(tab)
, column_name_(name) , column_name_(name)
, canonical_name_(build_canonical_name(table_, name)) , canonical_name_(build_canonical_name(table_, name))
, alias_(std::move(alias)) , alias_(std::move(alias))
, type_(type) , type_(type)
, attributes_(attributes) , attributes_(attributes)
, function_(func) {} , function_(func)
, expression_(expression) {}
table_column::table_column(const std::shared_ptr<abstract_column_expression>& expression) noexcept
: table_column(nullptr, "", "", utils::basic_type::Unknown, {}, sql::sql_function_t::None, expression) {}
table_column & table_column::operator=(const table_column &other) { table_column & table_column::operator=(const table_column &other) {
if (this == &other) { if (this == &other) {
@ -148,7 +153,7 @@ bool table_column::is_expression() const {
return static_cast<bool>(expression_); return static_cast<bool>(expression_);
} }
const column_expression_ptr& table_column::expression() const { std::shared_ptr<abstract_column_expression> table_column::expression() const {
return expression_; return expression_;
} }

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

@ -11,7 +11,7 @@ table_pk_generator::table_pk_generator(const std::string& table_name, const std:
query::update(table_name) query::update(table_name)
.set("next_id"_col, "next_id"_col + 1) .set("next_id"_col, "next_id"_col + 1)
.where("name"_col == sequence_name) .where("name"_col == sequence_name)
.returning(("next_id"_col - 1)); .returning(("next_id"_col - 1).as("id"));
/* /*
*UPDATE id_table *UPDATE id_table
SET next_id = next_id + 1 SET next_id = next_id + 1

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

@ -81,13 +81,13 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity
criteria_evaluator evaluator(db.dialect(), qc); criteria_evaluator evaluator(db.dialect(), qc);
for (const auto &[join_table, condition] : data.joins) { for (const auto &[join_table, condition] : data.joins) {
REQUIRE(join_table->table_name() == expected_join_data[index].first); REQUIRE(join_table->table_name() == expected_join_data[index].first);
REQUIRE(evaluator.evaluate(*condition) == expected_join_data[index].second); // REQUIRE(evaluator.evaluate(*condition) == expected_join_data[index].second);
++index; ++index;
} }
REQUIRE(data.where_clause.get()); // REQUIRE(data.where_clause.get());
auto cond = evaluator.evaluate(*data.where_clause); // auto cond = evaluator.evaluate(*data.where_clause);
REQUIRE(cond == R"("t01"."id" = ?)"); // REQUIRE(cond == R"("t01"."id" = ?)");
} }
TEST_CASE("Create sql query data for entity with eager belongs to", "[query][entity][builder]") { TEST_CASE("Create sql query data for entity with eager belongs to", "[query][entity][builder]") {
@ -144,16 +144,16 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
criteria_evaluator evaluator(db.dialect(), qc); criteria_evaluator evaluator(db.dialect(), qc);
for (const auto &join : data.joins) { for (const auto &join : data.joins) {
REQUIRE(join.join_table->table_name() == expected_join_data[index].first); REQUIRE(join.join_table->table_name() == expected_join_data[index].first);
REQUIRE(evaluator.evaluate(*join.condition) == expected_join_data[index].second); // REQUIRE(evaluator.evaluate(*join.condition) == expected_join_data[index].second);
++index; ++index;
} }
REQUIRE(data.where_clause.get()); // REQUIRE(data.where_clause.get());
auto cond = evaluator.evaluate(*data.where_clause); // auto cond = evaluator.evaluate(*data.where_clause);
REQUIRE(cond == R"("t01"."id" = ?)"); // REQUIRE(cond == R"("t01"."id" = ?)");
auto qs = matador::query::query::select(data.columns) // auto qs = matador::query::query::select(data.columns)
.from(data.root_table->name()); // .from(data.root_table->name());
// for (auto &jd : data.joins) { // for (auto &jd : data.joins) {
// qs.join_left(*jd.join_table) // qs.join_left(*jd.join_table)