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

added more has many to many test cases with different pk generators

This commit is contained in:
sascha 2026-05-12 16:04:11 +02:00
parent ceb7795d9c
commit e3618c60e3
1 changed files with 172 additions and 8 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
test/backends/SessionInsertHasManyToManyTest.cpp
View File

@ -14,6 +14,63 @@ using namespace matador::object;
using namespace matador::test;
using namespace matador::query::meta;
namespace matador::test {
template<const utils::primary_key_attribute &PkAttribute>
struct recipe_pk_generator;
template<const utils::primary_key_attribute &PkAttribute>
struct ingredient_pk_generator {
unsigned int id{};
std::string name;
collection<object_ptr<recipe_pk_generator<PkAttribute>>> recipes{};
ingredient_pk_generator() = default;
explicit ingredient_pk_generator(std::string name)
: name(std::move(name)) {
}
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id, PkAttribute);
field::attribute(op, "name", name, UniqueVarChar255);
field::has_many_to_many(op, "recipe_ingredients", recipes, "ingredient_id", "recipe_id", utils::CascadeAllFetchEager);
}
};
template<const utils::primary_key_attribute &PkAttribute>
struct recipe_pk_generator {
unsigned int id{};
std::string name;
collection<object_ptr<ingredient_pk_generator<PkAttribute>>> ingredients{};
recipe_pk_generator() = default;
explicit recipe_pk_generator(std::string name)
: name(std::move(name)) {
}
recipe_pk_generator(std::string name, std::vector<object_ptr<ingredient_pk_generator<PkAttribute>>> ings)
: name(std::move(name))
, ingredients(std::move(ings)){
}
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id, PkAttribute);
field::attribute(op, "name", name, UniqueVarChar255);
field::has_many_to_many(op, "recipe_ingredients", ingredients, utils::CascadeAllFetchLazy);
}
};
using ingredient_identity = ingredient_pk_generator<utils::Identity>;
using ingredient_table = ingredient_pk_generator<utils::Table>;
using ingredient_sequence = ingredient_pk_generator<utils::Sequence>;
using recipe_identity = recipe_pk_generator<utils::Identity>;
using recipe_table = recipe_pk_generator<utils::Table>;
using recipe_sequence = recipe_pk_generator<utils::Sequence>;
}
TEST_CASE_METHOD(SessionFixture, "Test insert object with has many to many relation", "[session][insert][has_many_to_many]") {
auto result = schema.attach<recipe>("recipes")
.and_then( [this] { return schema.attach<ingredient>("ingredients"); } )
@ -38,19 +95,126 @@ TEST_CASE_METHOD(SessionFixture, "Test insert object with has many to many relat
};
for (auto &r: recipes) {
REQUIRE(r.is_transient());
auto res = ses.insert(r);
REQUIRE(res.is_ok());
REQUIRE(res->is_persistent());
}
auto recipe_result = ses.find<recipe>(1);
// auto recipe_result = ses.find<recipe>(RECIPE.id == 1);
REQUIRE(recipe_result.is_ok());
REQUIRE(recipe_result->is_persistent());
REQUIRE(recipe_result.value()->ingredients.size() == 3);
}
// auto r = *recipe_result->begin();
auto r = *recipe_result;
std::cout << r->name << " (ingredients: " << r->ingredients.size() << ")" << std::endl;
// REQUIRE(r->name != "");
for (const auto &ingr: r->ingredients) {
std::cout << " " << ingr->name << std::endl;
TEST_CASE_METHOD(SessionFixture, "Test insert object with has many to many relation identity", "[session][insert][identity][has_many_to_many]") {
auto result = schema.attach<recipe_identity>("recipes")
.and_then( [this] { return schema.attach<ingredient_identity>("ingredients"); } )
.and_then([this] { return schema.create(db); } );
query::session ses({bus, connection::dns, 4}, schema);
std::vector ingredients {
make_object<ingredient_identity>("Apple"),
make_object<ingredient_identity>("Strawberry"),
make_object<ingredient_identity>("Pineapple"),
make_object<ingredient_identity>("Sugar"),
make_object<ingredient_identity>("Flour"),
make_object<ingredient_identity>("Butter"),
make_object<ingredient_identity>("Beans")
};
std::vector recipes {
make_object<recipe_identity>("Apple Pie", std::vector{ingredients[0], ingredients[3], ingredients[4]}),
make_object<recipe_identity>("Strawberry Cake", std::vector{ingredients[5], ingredients[6]}),
make_object<recipe_identity>("Pineapple Pie", std::vector{ingredients[0], ingredients[1], ingredients[2]})
};
for (auto &r: recipes) {
REQUIRE(r.is_transient());
auto res = ses.insert(r);
REQUIRE(res.is_ok());
REQUIRE(res->is_persistent());
}
auto recipe_result = ses.find<recipe_identity>(1);
REQUIRE(recipe_result.is_ok());
REQUIRE(recipe_result->is_persistent());
REQUIRE(recipe_result.value()->ingredients.size() == 3);
}
TEST_CASE_METHOD(SessionFixture, "Test insert object with has many to many relation table sequence", "[session][insert][table_sequence][has_many_to_many]") {
auto result = schema.attach<recipe_table>("recipes")
.and_then( [this] { return schema.attach<ingredient_table>("ingredients"); } )
.and_then([this] { return schema.create(db); } );
query::session ses({bus, connection::dns, 4}, schema);
std::vector ingredients {
make_object<ingredient_table>("Apple"),
make_object<ingredient_table>("Strawberry"),
make_object<ingredient_table>("Pineapple"),
make_object<ingredient_table>("Sugar"),
make_object<ingredient_table>("Flour"),
make_object<ingredient_table>("Butter"),
make_object<ingredient_table>("Beans")
};
std::vector recipes {
make_object<recipe_table>("Apple Pie", std::vector{ingredients[0], ingredients[3], ingredients[4]}),
make_object<recipe_table>("Strawberry Cake", std::vector{ingredients[5], ingredients[6]}),
make_object<recipe_table>("Pineapple Pie", std::vector{ingredients[0], ingredients[1], ingredients[2]})
};
for (auto &r: recipes) {
REQUIRE(r.is_transient());
auto res = ses.insert(r);
REQUIRE(res.is_ok());
REQUIRE(res->is_persistent());
}
auto recipe_result = ses.find<recipe_table>(1);
REQUIRE(recipe_result.is_ok());
REQUIRE(recipe_result->is_persistent());
REQUIRE(recipe_result.value()->ingredients.size() == 3);
}
TEST_CASE_METHOD(SessionFixture, "Test insert object with has many to many relation sequence", "[session][insert][sequence][has_many_to_many]") {
auto result = schema.attach<recipe_sequence>("recipes")
.and_then( [this] { return schema.attach<ingredient_sequence>("ingredients"); } )
.and_then([this] { return schema.create(db); } );
query::session ses({bus, connection::dns, 4}, schema);
std::vector ingredients {
make_object<ingredient_sequence>("Apple"),
make_object<ingredient_sequence>("Strawberry"),
make_object<ingredient_sequence>("Pineapple"),
make_object<ingredient_sequence>("Sugar"),
make_object<ingredient_sequence>("Flour"),
make_object<ingredient_sequence>("Butter"),
make_object<ingredient_sequence>("Beans")
};
std::vector recipes {
make_object<recipe_sequence>("Apple Pie", std::vector{ingredients[0], ingredients[3], ingredients[4]}),
make_object<recipe_sequence>("Strawberry Cake", std::vector{ingredients[5], ingredients[6]}),
make_object<recipe_sequence>("Pineapple Pie", std::vector{ingredients[0], ingredients[1], ingredients[2]})
};
for (auto &r: recipes) {
REQUIRE(r.is_transient());
auto res = ses.insert(r);
REQUIRE(res.is_ok());
REQUIRE(res->is_persistent());
}
auto recipe_result = ses.find<recipe_sequence>(1);
REQUIRE(recipe_result.is_ok());
REQUIRE(recipe_result->is_persistent());
REQUIRE(recipe_result.value()->ingredients.size() == 3);
const auto ing_result = ses.find<ingredient_sequence>(ingredients[0]->id);
REQUIRE(ing_result.is_ok());
REQUIRE(ing_result.value()->recipes.size() == 2);
}