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

introduced make_object function to create object_ptr instances and removed some session::insert overloads for simplicity

This commit is contained in:
Sascha Kühl 2026-02-16 11:29:27 +01:00
parent a2a6448e03
commit ae7c1f510f
3 changed files with 63 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/matador/object/object_ptr.hpp
View File

@ -59,6 +59,11 @@ struct is_object_ptr : std::false_type {
template<typename Type>
struct is_object_ptr<object_ptr<Type> > : std::true_type {
};
template<class Type, typename... Args>
object_ptr<Type> make_object(Args &&... args) {
return object_ptr<Type>(std::make_shared<Type>(std::forward<Args>(args)...));
}
}
#endif //OBJECT_PTR_HPP

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

@ -107,12 +107,12 @@ public:
* @param obj Object to insert
* @return Inserted object
*/
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> insert(Type *obj);
// template<typename Type>
// utils::result<object::object_ptr<Type>, utils::error> insert(Type *obj);
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> insert(object::object_ptr<Type> obj);
template<class Type, typename... Args>
utils::result<object::object_ptr<Type>, utils::error> insert(Args &&... args);
// template<class Type, typename... Args>
// utils::result<object::object_ptr<Type>, utils::error> insert(Args &&... args);
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> update(const object::object_ptr<Type> &obj);
@ -157,28 +157,6 @@ private:
std::shared_ptr<sql::resolver_service> resolver_service_;
};
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::insert(Type *obj) {
std::shared_ptr<Type> ptr(obj);
const auto it = schema_.find(typeid(Type));
if (it == schema_.end()) {
return utils::failure(make_error(error_code::UnknownType, "Failed to determine requested type."));
}
auto res = query::query::insert()
.into(it->second.name(), query::generator::columns<Type>(schema_))
.values(query::generator::placeholders<Type>())
.prepare(*this);
if (!res) {
return utils::failure(res.err());
}
if (const auto insert_result = res->bind(*obj).execute(); !insert_result.is_ok()) {
return utils::failure(insert_result.err());
}
return utils::ok(object::object_ptr{ptr});
}
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::insert(object::object_ptr<Type> obj) {
const auto it = schema_.find(typeid(Type));
@ -200,11 +178,6 @@ utils::result<object::object_ptr<Type>, utils::error> session::insert(object::ob
return utils::ok(obj);
}
template<class Type, typename... Args>
utils::result<object::object_ptr<Type>, utils::error> session::insert(Args &&... args) {
return insert(new Type(std::forward<Args>(args)...));
}
class pk_object_binder final {
public:
explicit pk_object_binder(sql::statement &stmt, const size_t position)

110
test/backends/SessionTest.cpp
View File

@ -22,7 +22,7 @@ TEST_CASE_METHOD(SessionFixture, "Session insert test", "[session][insert]") {
} );
REQUIRE(result.is_ok());
auto plane = ses.insert<airplane>(1, "Boeing", "A380");
auto plane = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(plane.is_ok());
const auto res = ses.find<airplane>(1);
@ -40,7 +40,7 @@ TEST_CASE_METHOD(SessionFixture, "Session update test", "[session][update]") {
} );
REQUIRE(res.is_ok());
auto result = ses.insert<airplane>(1, "Boeing", "747");
auto result = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(result.is_ok());
const auto plane = result.value();
@ -72,7 +72,7 @@ TEST_CASE_METHOD(SessionFixture, "Session delete test", "[session][delete]") {
schema.initialize_executor(ses);
auto result = ses.insert<airplane>(1, "Boeing", "747");
auto result = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(result.is_ok());
const auto plane = result.value();
@ -94,9 +94,9 @@ TEST_CASE_METHOD(SessionFixture, "Session relation test", "[session][relation]")
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
auto plane = ses.insert<airplane>(1, "Boeing", "A380");
auto plane = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(plane.is_ok());
auto f = ses.insert<flight>(2, *plane, "sully");
auto f = ses.insert(make_object<flight>(2, *plane, "sully"));
REQUIRE(f.is_ok());
const auto res = ses.find<flight>(2);
@ -115,7 +115,7 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find object with id", "[session
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
auto a380 = ses.insert<airplane>(1, "Boeing", "A380");
auto a380 = ses.insert(make_object<airplane>(1, "Boeing", "A380"));
REQUIRE(a380.is_ok());
auto find_result = ses.find<airplane>(2);
@ -136,13 +136,14 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects", "[session][f
} );
REQUIRE(result.is_ok());
std::vector<std::unique_ptr<airplane>> planes;
planes.emplace_back(new airplane(1, "Airbus", "A380"));
planes.emplace_back(new airplane(2, "Boeing", "707"));
planes.emplace_back(new airplane(3, "Boeing", "747"));
std::vector planes {
make_object<airplane>(1, "Airbus", "A380"),
make_object<airplane>(2, "Boeing", "707"),
make_object<airplane>(3, "Boeing", "747"),
};
for (auto &&plane: planes) {
auto res = ses.insert(plane.release());
auto res = ses.insert(plane);
REQUIRE(res.is_ok());
}
@ -193,20 +194,21 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with one-to-ma
}
REQUIRE(author_repo.size() == 2);
std::vector<std::unique_ptr<book>> books;
books.emplace_back( new book{3, "Jurassic Park", author_repo[0], 1990} );
books.emplace_back( new book{4, "Timeline", author_repo[0], 1999} );
books.emplace_back( new book{5, "The Andromeda Strain", author_repo[0], 1969} );
books.emplace_back( new book{6, "Congo", author_repo[0], 1980} );
books.emplace_back( new book{7, "Prey", author_repo[0], 2002} );
books.emplace_back( new book{8, "Carrie", author_repo[1], 1974} );
books.emplace_back( new book{9, "The Shining", author_repo[1], 1977} );
books.emplace_back( new book{10, "It", author_repo[1], 1986} );
books.emplace_back( new book{11, "Misery", author_repo[1], 1987} );
books.emplace_back( new book{12, "The Dark Tower: The Gunslinger", author_repo[1], 1982} );
std::vector books {
make_object<book>(1, "Jurassic Park", author_repo[0], 1990),
make_object<book>(2, "Timeline", author_repo[0], 1999),
make_object<book>(3, "The Andromeda Strain", author_repo[0], 1969),
make_object<book>(4, "Congo", author_repo[0], 1980),
make_object<book>(5, "Prey", author_repo[0], 2002),
make_object<book>(6, "Carrie", author_repo[1], 1974),
make_object<book>(7, "The Shining", author_repo[1], 1977),
make_object<book>(8, "It", author_repo[1], 1986),
make_object<book>(9, "Misery", author_repo[1], 1987),
make_object<book>(10, "The Dark Tower: The Gunslinger", author_repo[1], 1982)
};
for (auto &&b: books) {
auto res = ses.insert(b.release());
auto res = ses.insert(b);
REQUIRE(res.is_ok());
}
@ -220,21 +222,18 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with one-to-ma
}
TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with one-to-many eager relation", "[session][find][one-to-many][eager]") {
// auto result = repo.attach<department>("departments")
// .and_then([this] { return repo.attach<employee>("employees"); })
auto result = schema.attach<employee>("employees")
.and_then([this] { return schema.attach<department>("departments"); })
.and_then([this] {
return schema.create(db);
} );
.and_then([this] { return schema.create(db); } );
REQUIRE(result.is_ok());
std::vector<std::unique_ptr<department>> departments;
departments.emplace_back(new department{1, "Insurance"});
departments.emplace_back(new department{2, "Invoice"});
std::vector departments {
make_object<department>(1, "Insurance"),
make_object<department>(2, "Invoice")
};
for (auto &&a: departments) {
auto res = ses.insert(a.release());
auto res = ses.insert(a);
REQUIRE(res.is_ok());
}
@ -248,20 +247,21 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with one-to-ma
}
REQUIRE(departments_repo.size() == 2);
std::vector<std::unique_ptr<employee>> employees;
employees.emplace_back( new employee{3, "George", "Orwell", departments_repo[0]} );
employees.emplace_back( new employee{4, "Chris", "Tucker", departments_repo[0]} );
employees.emplace_back( new employee{5, "Steven", "King", departments_repo[0]} );
employees.emplace_back( new employee{6, "John", "Wayne", departments_repo[0]} );
employees.emplace_back( new employee{7, "Clint", "Eastwood", departments_repo[0]} );
employees.emplace_back( new employee{8, "Emma", "Thompson", departments_repo[1]} );
employees.emplace_back( new employee{9, "Ed", "Wood", departments_repo[1]} );
employees.emplace_back( new employee{10, "Steven", "Spielberg", departments_repo[1]} );
employees.emplace_back( new employee{11, "Jane", "Fonda", departments_repo[1]} );
employees.emplace_back( new employee{12, "Julia", "Roberts", departments_repo[1]} );
std::vector employees {
make_object<employee>(1, "George", "Orwell", departments_repo[0]),
make_object<employee>(2, "Chris", "Tucker", departments_repo[0]),
make_object<employee>(3, "Steven", "King", departments_repo[0]),
make_object<employee>(4, "John", "Wayne", departments_repo[0]),
make_object<employee>(5, "Clint", "Eastwood", departments_repo[0]),
make_object<employee>(6, "Emma", "Thompson", departments_repo[1]),
make_object<employee>(7, "Ed", "Wood", departments_repo[1]),
make_object<employee>(8, "Steven", "Spielberg", departments_repo[1]),
make_object<employee>(9, "Jane", "Fonda", departments_repo[1]),
make_object<employee>(10, "Julia", "Roberts", departments_repo[1])
};
for (auto &&b: employees) {
auto res = ses.insert(b.release());
auto res = ses.insert(b);
REQUIRE(res.is_ok());
}
@ -285,13 +285,13 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with many-to-m
} );
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"))
make_object<ingredient>(1, "Apple"),
make_object<ingredient>(2, "Strawberry"),
make_object<ingredient>(3, "Pineapple"),
make_object<ingredient>(4, "Sugar"),
make_object<ingredient>(5, "Flour"),
make_object<ingredient>(6, "Butter"),
make_object<ingredient>(7, "Beans")
};
for (auto &i: ingredients) {
@ -300,15 +300,13 @@ TEST_CASE_METHOD(SessionFixture, "Use session to find all objects with many-to-m
}
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]}))
make_object<recipe>(1, "Apple Pie", std::vector{ingredients[0], ingredients[3], ingredients[4]}),
make_object<recipe>(2, "Strawberry Cake", std::vector{ingredients[5], ingredients[6]}),
make_object<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());
}
}