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

some improvements to select_query_builder and started insert_query_builder

Browse Source
This commit is contained in:
sascha
2026-02-08 22:38:11 +01:00
parent a498efd21d
commit 54e6786ceb
10 changed files with 217 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/backends/SessionTest.cpp
+22 -13
View File
@@ -284,22 +284,31 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with many-to-m
return schema.create(db);
} );
std::vector<std::unique_ptr<ingredient>> ingredients;
ingredients.push_back(std::make_unique<ingredient>(1, "Apple"));
ingredients.push_back(std::make_unique<ingredient>(2, "Strawberry"));
ingredients.push_back(std::make_unique<ingredient>(3, "Pineapple"));
ingredients.push_back(std::make_unique<ingredient>(4, "Sugar"));
ingredients.push_back(std::make_unique<ingredient>(5, "Flour"));
ingredients.push_back(std::make_unique<ingredient>(6, "Butter"));
ingredients.push_back(std::make_unique<ingredient>(7, "Beans"));
std::vector ingredients {
object_ptr(std::make_shared<ingredient>(1, "Apple")),
object_ptr(std::make_shared<ingredient>(2, "Strawberry")),
object_ptr(std::make_shared<ingredient>(3, "Pineapple")),
object_ptr(std::make_shared<ingredient>(4, "Sugar")),
object_ptr(std::make_shared<ingredient>(5, "Flour")),
object_ptr(std::make_shared<ingredient>(6, "Butter")),
object_ptr(std::make_shared<ingredient>(7, "Beans"))
};
for (auto &i: ingredients) {
auto res = ses.insert(i.release());
auto res = ses.insert(i);
REQUIRE(res.is_ok());
}
std::vector<std::unique_ptr<recipe>> recipes;
recipes.push_back(std::make_unique<recipe>(7, "Apple Crumble"));
recipes.push_back(std::make_unique<recipe>(8, "Beans Chili"));
recipes.push_back(std::make_unique<recipe>(9, "Fruit Salad"));
std::vector recipes {
object_ptr(std::make_shared<recipe>(1, "Apple Pie", std::vector{ingredients[0], ingredients[3], ingredients[4]})),
object_ptr(std::make_shared<recipe>(2, "Strawberry Cake", std::vector{ingredients[5], ingredients[6]})),
object_ptr(std::make_shared<recipe>(3, "Pineapple Pie", std::vector{ingredients[0], ingredients[1], ingredients[2]}))
};
for (auto &r: recipes) {
auto res = ses.insert(r);
REQUIRE(res.is_ok());
}
}
test/models/recipe.hpp
+6 -1
View File
@@ -9,6 +9,7 @@
#include "matador/object/many_to_many_relation.hpp"
#include <string>
#include <utility>
namespace matador::test {
struct recipe;
@@ -39,10 +40,14 @@ struct recipe {
object::collection<object::object_ptr<ingredient> > ingredients{};
recipe() = default;
recipe(const unsigned int id, std::string name)
: id(id), name(std::move(name)) {
}
recipe(const unsigned int id, std::string name, std::vector<object::object_ptr<ingredient>> ings)
: id(id)
, name(std::move(name))
, ingredients(std::move(ings)){
}
template<class Operator>
void process(Operator &op) {
test/orm/orm/SessionQueryBuilderTest.cpp
+118 -90
View File
@@ -3,7 +3,6 @@
#include "matador/sql/backend_provider.hpp"
#include "matador/sql/connection.hpp"
#include "matador/sql/connection_pool.hpp"
#include "matador/sql/interface/connection_impl.hpp"
#include "matador/query/criteria_evaluator.hpp"
@@ -37,53 +36,57 @@ TEST_CASE("Create sql query data for entity with eager has one", "[query][entity
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
connection_pool pool("noop://noop.db", 4);
schema scm;
auto result = scm.attach<airplane>("airplanes")
.and_then( [&scm] { return scm.attach<flight>("flights"); } );
REQUIRE(result);
select_query_builder eqb(scm, db);
select_query_builder eqb(scm);
const auto it = scm.find(typeid(flight));
REQUIRE(it != scm.end());
const auto* col = it->second.table()["id"];
REQUIRE(col);
auto data = eqb.build<flight>(*col == _);
auto q = eqb.build<flight>(*col == _);
REQUIRE(q.is_ok());
REQUIRE(data.is_ok());
REQUIRE(data->root_table->table_name() == "flights");
REQUIRE(data->joins.size() == 1);
const auto sql = q->str(db);
const std::string expected_sql = R"(SELECT "t01"."id", "t02"."id", "t02"."brand", "t02"."model", "t01"."pilot_name" FROM "flights" "t01" LEFT JOIN "airplanes" "t02" ON "t01"."airplane_id" = "t02"."id" WHERE "t01"."id" = ? ORDER BY "t01"."id" ASC)";
REQUIRE(expected_sql == sql);
const auto& data = eqb.query_data();
REQUIRE(data.root_table->table_name() == "flights");
REQUIRE(data.joins.size() == 1);
const auto flights = table("flights").as("t01");
const auto airplanes = table("airplanes").as("t02");
const std::vector<table_column> expected_columns {
{ &flights, "id", "c01" },
{ &airplanes, "id", "c02" },
{ &airplanes, "brand", "c03" },
{ &airplanes, "model", "c04" },
{ &flights, "pilot_name", "c05" },
};
REQUIRE(data->columns.size() == expected_columns.size());
{ &flights, "id", "c01" },
{ &airplanes, "id", "c02" },
{ &airplanes, "brand", "c03" },
{ &airplanes, "model", "c04" },
{ &flights, "pilot_name", "c05" },
};
REQUIRE(data.columns.size() == expected_columns.size());
for (size_t i = 0; i != expected_columns.size(); ++i) {
REQUIRE(expected_columns[i].equals(data->columns[i]));
REQUIRE(expected_columns[i].equals(data.columns[i]));
}
std::vector<std::pair<std::string, std::string>> expected_join_data {
{ "airplanes", R"("t01"."airplane_id" = "t02"."id")"}
{ "airplanes", R"("t01"."airplane_id" = "t02"."id")"}
};
query_context qc;
size_t index{0};
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(evaluator.evaluate(*condition) == expected_join_data[index].second);
++index;
}
REQUIRE(data->where_clause.get());
auto cond = evaluator.evaluate(*data->where_clause);
REQUIRE(data.where_clause.get());
auto cond = evaluator.evaluate(*data.where_clause);
REQUIRE(cond == R"("t01"."id" = ?)");
}
@@ -91,24 +94,29 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
connection_pool pool("noop://noop.db", 4);
schema scm;
auto result = scm.attach<author>("authors")
.and_then( [&scm] { return scm.attach<book>("books"); } );
REQUIRE(result);
select_query_builder eqb(scm, db);
select_query_builder eqb(scm);
const auto it = scm.find(typeid(book));
REQUIRE(it != scm.end());
const auto* col = it->second.table()["id"];
REQUIRE(col);
auto data = eqb.build<book>(*col == _);
auto q = eqb.build<book>(*col == _);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->table_name() == "books");
REQUIRE(data->joins.size() == 1);
REQUIRE(q.is_ok());
const auto sql = q->str(db);
const std::string expected_sql = R"(SELECT "t01"."id", "t01"."title", "t02"."id", "t02"."first_name", "t02"."last_name", "t02"."date_of_birth", "t02"."year_of_birth", "t02"."distinguished", "t01"."published_in" FROM "books" "t01" LEFT JOIN "authors" "t02" ON "t01"."author_id" = "t02"."id" WHERE "t01"."id" = ? ORDER BY "t01"."id" ASC)";
REQUIRE(expected_sql == sql);
const auto& data = eqb.query_data();
REQUIRE(data.root_table->table_name() == "books");
REQUIRE(data.joins.size() == 1);
const auto books = table("books").as("t01");
const auto authors = table("authors").as("t02");
const std::vector<table_column> expected_columns {
@@ -122,9 +130,9 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
{ &authors, "distinguished", "c08" },
{ &books, "published_in", "c09" }
};
REQUIRE(data->columns.size() == expected_columns.size());
REQUIRE(data.columns.size() == expected_columns.size());
for (size_t i = 0; i != expected_columns.size(); ++i) {
REQUIRE(expected_columns[i].equals(data->columns[i]));
REQUIRE(expected_columns[i].equals(data.columns[i]));
}
std::vector<std::pair<std::string, std::string>> expected_join_data {
@@ -134,33 +142,32 @@ TEST_CASE("Create sql query data for entity with eager belongs to", "[query][ent
query_context qc;
size_t index{0};
criteria_evaluator evaluator(db.dialect(), qc);
for (const auto & [join_table, clause] : data->joins) {
for (const auto & [join_table, clause] : data.joins) {
REQUIRE(join_table->table_name() == expected_join_data[index].first);
REQUIRE(evaluator.evaluate(*clause) == expected_join_data[index].second);
++index;
}
REQUIRE(data->where_clause.get());
auto cond = evaluator.evaluate(*data->where_clause);
REQUIRE(data.where_clause.get());
auto cond = evaluator.evaluate(*data.where_clause);
REQUIRE(cond == R"("t01"."id" = ?)");
auto q = matador::query::query::select(data->columns)
.from(data->root_table->name());
auto qs = matador::query::query::select(data.columns)
.from(data.root_table->name());
for (auto &jd : data->joins) {
q.join_left(*jd.join_table)
.on(std::move(jd.condition));
}
auto context = q
.where(std::move(data->where_clause))
.str(db);
// for (auto &jd : data.joins) {
// qs.join_left(*jd.join_table)
// .on(std::move(jd.condition));
// }
// auto context = qs
// .where(std::move(data.where_clause))
// .str(db);
}
TEST_CASE("Create sql query data for entity with eager has many belongs to", "[query][entity][builder]") {
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
connection_pool pool("noop://noop.db", 4);
schema scm;
auto result = scm.attach<product>("products")
@@ -170,17 +177,23 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
.and_then( [&scm] { return scm.attach<order>("orders"); } );
REQUIRE(result);
select_query_builder eqb(scm, db);
select_query_builder eqb(scm);
const auto it = scm.find(typeid(order));
REQUIRE(it != scm.end());
const auto* col = it->second.table()["order_id"];
REQUIRE(col);
auto data = eqb.build<order>(*col == _);
auto q = eqb.build<order>(*col == _);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->table_name() == "orders");
REQUIRE(data->joins.size() == 1);
REQUIRE(q.is_ok());
const auto sql = q->str(db);
const std::string expected_sql = R"(SELECT "t01"."order_id", "t01"."order_date", "t01"."required_date", "t01"."shipped_date", "t01"."ship_via", "t01"."freight", "t01"."ship_name", "t01"."ship_address", "t01"."ship_city", "t01"."ship_region", "t01"."ship_postal_code", "t01"."ship_country", "t02"."order_details_id", "t02"."order_id", "t02"."product_id" FROM "orders" "t01" LEFT JOIN "order_details" "t02" ON "t01"."order_id" = "t02"."order_id" WHERE "t01"."order_id" = ? ORDER BY "t01"."order_id" ASC)";
REQUIRE(expected_sql == sql);
const auto& data = eqb.query_data();
REQUIRE(data.root_table->table_name() == "orders");
REQUIRE(data.joins.size() == 1);
const auto orders = table("orders").as("t01");
const auto order_details = table("order_details").as("t02");
const std::vector<table_column> expected_columns = {
@@ -200,9 +213,9 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
{ &order_details, "order_id", "c14" },
{ &order_details, "product_id", "c15" }
};
REQUIRE(data->columns.size() == expected_columns.size());
REQUIRE(data.columns.size() == expected_columns.size());
for (size_t i = 0; i != expected_columns.size(); ++i) {
REQUIRE(expected_columns[i].equals(data->columns[i]));
REQUIRE(expected_columns[i].equals(data.columns[i]));
}
std::vector<std::pair<std::string, std::string>> expected_join_data {
@@ -212,39 +225,44 @@ TEST_CASE("Create sql query data for entity with eager has many belongs to", "[q
query_context qc;
size_t index{0};
criteria_evaluator evaluator(db.dialect(), qc);
for (const auto &jd : data->joins) {
for (const auto &jd : data.joins) {
REQUIRE(jd.join_table->table_name() == expected_join_data[index].first);
REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
// REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
++index;
}
REQUIRE(data->where_clause.get());
auto cond = evaluator.evaluate(*data->where_clause);
REQUIRE(cond == R"("t01"."order_id" = ?)");
// REQUIRE(data.where_clause.get());
// auto cond = evaluator.evaluate(*data.where_clause);
// REQUIRE(cond == R"("t01"."order_id" = ?)");
}
TEST_CASE("Create sql query data for entity with eager many to many", "[query][entity][builder]") {
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
connection_pool pool("noop://noop.db", 4);
schema scm;
auto result = scm.attach<recipe>("recipes")
.and_then( [&scm] { return scm.attach<ingredient>("ingredients"); } );
REQUIRE(result);
select_query_builder eqb(scm, db);
select_query_builder eqb(scm);
const auto it = scm.find(typeid(ingredient));
REQUIRE(it != scm.end());
const auto* col = it->second.table()["id"];
REQUIRE(col);
auto data = eqb.build<ingredient>(*col == _);
auto q = eqb.build<ingredient>(*col == _);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->table_name() == "ingredients");
REQUIRE(data->joins.size() == 2);
REQUIRE(q.is_ok());
const auto sql = q->str(db);
const std::string expected_sql = R"(SELECT "t01"."id", "t01"."name", "t03"."id", "t03"."name" FROM "ingredients" "t01" LEFT JOIN "recipe_ingredients" "t02" ON "t01"."id" = "t02"."ingredient_id" LEFT JOIN "recipes" "t03" ON "t02"."recipe_id" = "t03"."id" WHERE "t01"."id" = ? ORDER BY "t01"."id" ASC)";
REQUIRE(expected_sql == sql);
const auto& data = eqb.query_data();
REQUIRE(data.root_table->table_name() == "ingredients");
REQUIRE(data.joins.size() == 2);
const auto ingredients = table("ingredients").as("t01");
const auto recipes = table("recipes").as("t03");
const std::vector<table_column> expected_columns {
@@ -253,9 +271,9 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
{ &recipes, "id", "c03" },
{ &recipes, "name", "c04" }
};
REQUIRE(data->columns.size() == expected_columns.size());
REQUIRE(data.columns.size() == expected_columns.size());
for (size_t i = 0; i != expected_columns.size(); ++i) {
REQUIRE(expected_columns[i].equals(data->columns[i]));
REQUIRE(expected_columns[i].equals(data.columns[i]));
}
std::vector<std::pair<std::string, std::string>> expected_join_data {
@@ -266,39 +284,44 @@ TEST_CASE("Create sql query data for entity with eager many to many", "[query][e
query_context qc;
size_t index{0};
criteria_evaluator evaluator(db.dialect(), qc);
for (const auto &jd : data->joins) {
for (const auto &jd : data.joins) {
REQUIRE(jd.join_table->table_name() == expected_join_data[index].first);
REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
// REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
++index;
}
REQUIRE(data->where_clause.get());
auto cond = evaluator.evaluate(*data->where_clause);
REQUIRE(cond == R"("t01"."id" = ?)");
// REQUIRE(data.where_clause.get());
// auto cond = evaluator.evaluate(*data.where_clause);
// REQUIRE(cond == R"("t01"."id" = ?)");
}
TEST_CASE("Create sql query data for entity with eager many to many (inverse part)", "[query][entity][builder]") {
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
connection_pool pool("noop://noop.db", 4);
schema scm;
auto result = scm.attach<student>("students")
.and_then( [&scm] { return scm.attach<course>("courses"); } );
REQUIRE(result);
select_query_builder eqb(scm, db);
select_query_builder eqb(scm);
const auto it = scm.find(typeid(course));
REQUIRE(it != scm.end());
const auto* col = it->second.table()["id"];
REQUIRE(col);
auto data = eqb.build<course>(*col == _);
auto q = eqb.build<course>(*col == _);
REQUIRE(data.is_ok());
REQUIRE(data->root_table->table_name() == "courses");
REQUIRE(data->joins.size() == 2);
REQUIRE(q.is_ok());
const auto sql = q->str(db);
const std::string expected_sql = R"(SELECT "t01"."id", "t01"."title", "t03"."id", "t03"."name" FROM "courses" "t01" LEFT JOIN "student_courses" "t02" ON "t01"."id" = "t02"."course_id" LEFT JOIN "students" "t03" ON "t02"."student_id" = "t03"."id" WHERE "t01"."id" = ? ORDER BY "t01"."id" ASC)";
REQUIRE(expected_sql == sql);
const auto& data = eqb.query_data();
REQUIRE(data.root_table->table_name() == "courses");
REQUIRE(data.joins.size() == 2);
const auto courses = table("courses").as("t01");
const auto students = table("students").as("t03");
const std::vector<table_column> expected_columns {
@@ -307,9 +330,9 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
{ &students, "id", "c03" },
{ &students, "name", "c04" }
};
REQUIRE(data->columns.size() == expected_columns.size());
REQUIRE(data.columns.size() == expected_columns.size());
for (size_t i = 0; i != expected_columns.size(); ++i) {
REQUIRE(expected_columns[i].equals(data->columns[i]));
REQUIRE(expected_columns[i].equals(data.columns[i]));
}
std::vector<std::pair<std::string, std::string>> expected_join_data {
@@ -320,40 +343,45 @@ TEST_CASE("Create sql query data for entity with eager many to many (inverse par
query_context qc;
size_t index{0};
criteria_evaluator evaluator(db.dialect(), qc);
for (const auto &jd : data->joins) {
for (const auto &jd : data.joins) {
REQUIRE(jd.join_table->table_name() == expected_join_data[index].first);
REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
// REQUIRE(evaluator.evaluate(*jd.condition) == expected_join_data[index].second);
++index;
}
REQUIRE(data->where_clause.get());
auto cond = evaluator.evaluate(*data->where_clause);
REQUIRE(cond == R"("t01"."id" = ?)");
// REQUIRE(data.where_clause.get());
// auto cond = evaluator.evaluate(*data.where_clause);
// REQUIRE(cond == R"("t01"."id" = ?)");
}
TEST_CASE("Test eager relationship", "[query][entity][builder]") {
using namespace matador::test;
backend_provider::instance().register_backend("noop", std::make_unique<orm::test_backend_service>());
connection db("noop://noop.db");
connection_pool pool("noop://noop.db", 4);
schema scm;
auto result = scm.attach<department>("departments")
.and_then( [&scm] { return scm.attach<employee>("employees"); } );
REQUIRE(result);
select_query_builder eqb(scm, db);
select_query_builder eqb(scm);
auto data = eqb.build<department>();
REQUIRE(data.is_ok());
auto q = eqb.build<department>();
REQUIRE(q.is_ok());
const auto sql = q->str(db);
const std::string expected_sql = R"(SELECT "t01"."id", "t01"."name", "t02"."id", "t02"."first_name", "t02"."last_name", "t02"."dep_id" FROM "departments" "t01" LEFT JOIN "employees" "t02" ON "t01"."id" = "t02"."dep_id" ORDER BY "t01"."id" ASC)";
REQUIRE(expected_sql == sql);
auto ctx = query::select(data->columns)
.from(*data->root_table)
.join_left(data->joins)
.where(std::move(data->where_clause))
.order_by(table_column{data->root_table, data->pk_column_name})
.asc()
.str(db);
const auto& data = eqb.query_data();
std::cout << ctx << std::endl;
// auto ctx = query::select(data.columns)
// .from(*data.root_table)
// .join_left(data.joins)
// .where(std::move(data.where_clause))
// .order_by(table_column{data.root_table, data.pk_column_name})
// .asc()
// .str(db);
//
// std::cout << ctx << std::endl;
}