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

resolve has one progress

Browse Source
This commit is contained in:
sascha
2026-05-17 21:46:43 +02:00
parent 57703dfb67
commit 9f54716df2
16 changed files with 86 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/matador/object/collection_resolver_factory.hpp
+7 -5
View File
@@ -3,6 +3,8 @@
#include "matador/object/collection_resolver.hpp"
#include <memory>
namespace matador::object {
class abstract_collection_resolver_factory {
public:
@@ -29,20 +31,20 @@ class abstract_joined_object_resolver_factory {
public:
virtual ~abstract_joined_object_resolver_factory() = default;
[[nodiscard]] virtual std::shared_ptr<abstract_joined_resolver> acquire_joined_object_resolver(const std::type_index &root_type, const std::type_index &element_type, const std::string &collection_name) const = 0;
virtual void register_joined_object_resolver(std::shared_ptr<abstract_joined_resolver> &&resolver) = 0;
[[nodiscard]] virtual std::shared_ptr<abstract_type_resolver> acquire_joined_object_resolver(const std::type_index &root_type, const std::type_index &element_type, const std::string &collection_name) const = 0;
virtual void register_joined_object_resolver(std::shared_ptr<abstract_type_resolver> &&resolver, const std::type_index& root_type, const std::string& join_column) = 0;
};
class joined_object_resolver_factory : public abstract_joined_object_resolver_factory {
public:
template<class Type>
[[nodiscard]] std::shared_ptr<joined_object_resolver<Type>> resolver(const std::type_index &root_type, const std::string &collection_name) const {
[[nodiscard]] std::shared_ptr<object_resolver<Type>> resolver(const std::type_index &root_type, const std::string &collection_name) const {
const auto res = acquire_joined_object_resolver(root_type, typeid(Type), collection_name);
if (!res) {
return std::dynamic_pointer_cast<joined_object_resolver<Type>>(res);
return std::dynamic_pointer_cast<object_resolver<Type>>(res);
}
return std::dynamic_pointer_cast<joined_object_resolver<Type>>(res);
return std::dynamic_pointer_cast<object_resolver<Type>>(res);
}
};
}
include/matador/object/object_ptr.hpp
+1
View File
@@ -55,6 +55,7 @@ public:
}
void reset() { proxy_.reset(); }
void reset(const std::shared_ptr<object_proxy<Type>>& proxy) { proxy_ = proxy; }
operator bool() const { return valid(); }
[[nodiscard]] bool valid() const { return proxy_ != nullptr && !proxy_->empty(); }
include/matador/object/object_resolver.hpp
+4 -3
View File
@@ -19,11 +19,12 @@ public:
virtual std::shared_ptr<Type> resolve(const utils::identifier& id) = 0;
};
template<typename Type>
class joined_object_resolver : public abstract_joined_resolver {
class joined_object_resolver : public abstract_joined_resolver, public object_resolver<Type> {
public:
joined_object_resolver(const std::type_index& root_type, const std::string& join_column) : abstract_joined_resolver(root_type, typeid(Type), join_column) {}
joined_object_resolver(const std::type_index& root_type, const std::string& join_column)
: abstract_joined_resolver(root_type, typeid(Type), join_column) {}
virtual std::shared_ptr<Type> resolve(const utils::identifier& id) = 0;
std::shared_ptr<Type> resolve(const utils::identifier& id) override = 0;
};
}
#endif //MATADOR_OBJECT_LOADER_HPP
include/matador/query/basic_schema.hpp
+2 -2
View File
@@ -103,7 +103,7 @@ public:
[[nodiscard]] const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>>& resolver_producers() const;
[[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash>& collection_resolver_producers() const;
[[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::object_resolver_producer>, object::collection_composite_key_hash>& joined_object_resolver_producers() const;
[[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_object_resolver_producer>, object::collection_composite_key_hash>& joined_object_resolver_producers() const;
protected:
template<typename Type>
@@ -114,7 +114,7 @@ protected:
std::unordered_map<std::type_index, schema_node> schema_nodes_;
std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>> resolver_producers_;
std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash> collection_resolver_producers_;
std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::object_resolver_producer>, object::collection_composite_key_hash> joined_object_resolver_producers_;
std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::joined_object_resolver_producer>, object::collection_composite_key_hash> joined_object_resolver_producers_;
};
}
#endif //MATADOR_BASIC_SCHEMA_HPP
include/matador/query/query_object_resolver.hpp
+22
View File
@@ -22,6 +22,17 @@ protected:
sql::statement stmt_;
};
template<typename Type>
class query_joined_object_resolver : public object::joined_object_resolver<Type> {
public:
explicit query_joined_object_resolver(sql::statement &&stmt)
: stmt_(std::move(stmt)) {}
std::shared_ptr<Type> resolve(const utils::identifier &id) override;
protected:
sql::statement stmt_;
};
template<typename Type>
std::shared_ptr<Type> query_object_resolver<Type>::resolve(const utils::identifier &id) {
sql::identifier_statement_binder binder(stmt_);
@@ -34,5 +45,16 @@ std::shared_ptr<Type> query_object_resolver<Type>::resolve(const utils::identifi
return *result;
}
template<typename Type>
std::shared_ptr<Type> query_joined_object_resolver<Type>::resolve(const utils::identifier &id) {
sql::identifier_statement_binder binder(stmt_);
binder.bind(id);
auto result = stmt_.template fetch_one_raw<Type>();
if (!result) {
return nullptr;
}
return *result;
}
}
#endif //MATADOR_QUERY_OBJECT_LOADER_HPP
include/matador/query/schema.hpp
+23 -11
View File
@@ -45,22 +45,17 @@ template<typename Type>
class query_joined_object_resolver_producer : public sql::joined_object_resolver_producer {
public:
query_joined_object_resolver_producer() = default;
query_joined_object_resolver_producer(basic_schema& repo, const table& tab, std::string pk_name, const std::type_index& root_type, std::string join_column)
query_joined_object_resolver_producer(basic_schema& repo, const table& tab, std::string pk_name, const std::type_index& root_type, const std::string &join_column)
: joined_object_resolver_producer(root_type, typeid(Type), join_column)
, repo_(repo)
, table_(tab)
, pk_name_(std::move(pk_name)) {}
std::shared_ptr<object::abstract_joined_resolver> produce(sql::statement&& stmt) override {
std::shared_ptr<object::abstract_type_resolver> produce(sql::statement&& stmt) override {
return std::make_shared<query_object_resolver<Type>>(std::move(stmt));
}
utils::result<sql::query_context, utils::error> build_query(const sql::dialect& d) override {
const auto *pk_column = table_[pk_name_];
const auto *join_column = table_[collection_name()];
return utils::ok(sql::query_context{});
}
utils::result<sql::query_context, utils::error> build_query(const sql::dialect& /*d*/) override;
private:
basic_schema& repo_;
@@ -162,9 +157,11 @@ public:
throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"};
}
auto producer = std::make_unique<query_object_resolver_producer<typename Pointer::value_type>>(
auto producer = std::make_unique<query_joined_object_resolver_producer<typename Pointer::value_type>>(
schema_,
it->second.table(),
it->second.node().info().primary_key_attribute()->name(),
root_type_,
join_column);
const object::collection_composite_key key{root_type_, typeid(Pointer), join_column};
schema_.joined_object_resolver_producers_[key] = std::move(producer);
@@ -338,8 +335,7 @@ utils::result<void, utils::error> schema::drop_table(const sql::connection &conn
}
template<typename Type>
utils::result<sql::query_context, utils::error> query_object_resolver_producer<Type>::
build_query(const sql::dialect &d) {
utils::result<sql::query_context, utils::error> query_object_resolver_producer<Type>::build_query(const sql::dialect &d) {
producer_creator pc(repo_, typeid(Type));
Type obj;
access::process(pc, obj);
@@ -354,6 +350,22 @@ build_query(const sql::dialect &d) {
return utils::ok(result->compile(d));
}
template<typename Type>
utils::result<sql::query_context, utils::error> query_joined_object_resolver_producer<Type>::build_query(const sql::dialect &d) {
// producer_creator pc(repo_, typeid(Type));
// Type obj;
// access::process(pc, obj);
select_query_builder qb(repo_);
const auto *join_column = table_[collection_name()];
const auto result = qb.build<Type>(*join_column == utils::_);
if (!result) {
return utils::failure(result.err());
}
return utils::ok(result->compile(d));
}
template <typename Type>
void schema_observer<Type>::on_attach(const object::repository_node &node, const Type &/*prototype*/) const {
primary_key_generator_finder finder;
include/matador/sql/internal/object_resolver_producer.hpp
+1 -1
View File
@@ -32,7 +32,7 @@ class joined_object_resolver_producer {
public:
virtual ~joined_object_resolver_producer() = default;
virtual utils::result<query_context, utils::error> build_query(const dialect& d) = 0;
virtual std::shared_ptr<object::abstract_joined_resolver> produce(statement&& stmt) = 0;
virtual std::shared_ptr<object::abstract_type_resolver> produce(statement&& stmt) = 0;
[[nodiscard]] const std::type_index& root_type() const;
[[nodiscard]] const std::type_index& type() const;
include/matador/sql/internal/query_result_impl.hpp
+3 -3
View File
@@ -130,16 +130,16 @@ void query_result_impl::on_belongs_to(const char*, Pointer& x, const utils::fore
template <class PointerType>
void query_result_impl::on_has_one(const char*, object::object_ptr<PointerType>& x, const char *join_column, const utils::foreign_attributes& attr) {
const auto resolver = resolver_->collection_resolver<PointerType>(result_type_, join_column);
const auto resolver = resolver_->joined_object_resolver<PointerType>(result_type_, join_column);
if (attr.fetch() == utils::fetch_type::Lazy) {
x = object::object_ptr<PointerType>(std::make_shared<object::object_proxy<PointerType>>(resolver, id_reader_.read(x, column_index_++)));
x.reset(std::make_shared<object::object_proxy<PointerType>>(resolver, utils::identifier{}));
} else {
auto obj = std::make_shared<PointerType>();
const auto ti = std::type_index(typeid(*x));
type_stack_.push(ti);
access::process(*this, *obj);
type_stack_.pop();
x = object::object_ptr<PointerType>(std::make_shared<object::object_proxy<PointerType>>(resolver, obj));
x.reset(std::make_shared<object::object_proxy<PointerType>>(resolver, obj));
}
}
include/matador/sql/producer_resolver_factory.hpp
+3 -3
View File
@@ -33,13 +33,13 @@ private:
class producer_joined_object_resolver_factory : public object::joined_object_resolver_factory {
public:
[[nodiscard]] std::shared_ptr<object::abstract_joined_resolver> acquire_joined_object_resolver(const std::type_index& root_type,
[[nodiscard]] std::shared_ptr<object::abstract_type_resolver> acquire_joined_object_resolver(const std::type_index& root_type,
const std::type_index& element_type,
const std::string& collection_name) const override;
void register_joined_object_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) override;
void register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver, const std::type_index& root_type, const std::string& join_column) override;
private:
std::unordered_map<object::collection_composite_key, std::shared_ptr<object::abstract_joined_resolver>, object::collection_composite_key_hash> resolvers_;
std::unordered_map<object::collection_composite_key, std::shared_ptr<object::abstract_type_resolver>, object::collection_composite_key_hash> resolvers_;
};
}
#endif //MATADOR_RESOLVER_FACTORY_HPP
include/matador/sql/resolver_service.hpp
+5 -5
View File
@@ -17,18 +17,18 @@ public:
}
template<class Type>
std::shared_ptr<object::collection_resolver<Type>> joined_object_resolver(const std::type_index &root_type, const std::string &join_column) const {
std::shared_ptr<object::object_resolver<Type>> joined_object_resolver(const std::type_index &root_type, const std::string &join_column) const {
return joined_object_resolver_factory_.resolver<Type>(root_type, join_column);
}
void register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver);
void register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver);
void register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver);
void register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver, const std::type_index& root_type, const std::string& join_column);
private:
sql::producer_resolver_factory object_resolver_factory_;
sql::producer_collection_resolver_factory collection_resolver_factory_;
sql::producer_resolver_factory joined_object_resolver_factory_;
producer_resolver_factory object_resolver_factory_;
producer_collection_resolver_factory collection_resolver_factory_;
producer_joined_object_resolver_factory joined_object_resolver_factory_;
};
}
#endif // MATADOR_RESOLVER_SERVICE_HPP