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

has one progress

This commit is contained in:
sascha 2026-05-15 15:22:59 +02:00
parent 22f6f71412
commit 57703dfb67
44 changed files with 288 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/matador/object/abstract_collection_resolver.hpp → include/matador/object/abstract_joined_resolver.hpp
View File

@ -1,24 +1,22 @@
#ifndef MATADOR_ABSTRACT_COLLECTION_RESOLVER_HPP
#define MATADOR_ABSTRACT_COLLECTION_RESOLVER_HPP
#include "matador/object/abstract_type_resolver.hpp"
#include <string>
#include <typeindex>
namespace matador::object {
class abstract_collection_resolver {
class abstract_joined_resolver : public abstract_type_resolver {
public:
virtual ~abstract_collection_resolver() = default;
[[nodiscard]] const std::type_index& root_type() const;
[[nodiscard]] const std::type_index& type() const;
[[nodiscard]] const std::string& collection_name() const;
protected:
explicit abstract_collection_resolver(const std::type_index& root_type, const std::type_index& type, std::string collection_name);
explicit abstract_joined_resolver(const std::type_index& root_type, const std::type_index& type, std::string collection_name);
public:
const std::type_index root_type_;
const std::type_index type_;
const std::string collection_name_;
};
}

6
include/matador/object/collection_resolver.hpp
View File

@ -1,7 +1,7 @@
#ifndef MATADOR_COLLECTION_RESOLVER_HPP
#define MATADOR_COLLECTION_RESOLVER_HPP
#include "matador/object/abstract_collection_resolver.hpp"
#include "matador/object/abstract_joined_resolver.hpp"
#include <typeindex>
#include <vector>
@ -12,10 +12,10 @@ class identifier;
namespace matador::object {
template<typename Type>
class collection_resolver : public abstract_collection_resolver {
class collection_resolver : public abstract_joined_resolver {
public:
collection_resolver(const std::type_index& root_type, std::string collection_name)
: abstract_collection_resolver(root_type, typeid(Type), std::move(collection_name)) {}
: abstract_joined_resolver(root_type, typeid(Type), std::move(collection_name)) {}
virtual std::vector<Type> resolve(const utils::identifier& id) = 0;
};

25
include/matador/object/collection_resolver_factory.hpp
View File

@ -8,8 +8,8 @@ class abstract_collection_resolver_factory {
public:
virtual ~abstract_collection_resolver_factory() = default;
[[nodiscard]] virtual std::shared_ptr<abstract_collection_resolver> acquire_collection_resolver(const std::type_index &root_type, const std::type_index &element_type, const std::string &collection_name) const = 0;
virtual void register_collection_resolver(std::shared_ptr<abstract_collection_resolver> &&resolver) = 0;
[[nodiscard]] virtual std::shared_ptr<abstract_joined_resolver> acquire_collection_resolver(const std::type_index &root_type, const std::type_index &element_type, const std::string &collection_name) const = 0;
virtual void register_collection_resolver(std::shared_ptr<abstract_joined_resolver> &&resolver) = 0;
};
class collection_resolver_factory : public abstract_collection_resolver_factory {
@ -24,5 +24,26 @@ public:
return std::dynamic_pointer_cast<collection_resolver<Type>>(res);
}
};
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;
};
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 {
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<joined_object_resolver<Type>>(res);
}
};
}
#endif //MATADOR_CONTAINER_RESOLVER_FACTORY_HPP

4
include/matador/object/foreign_node_completer.hpp
View File

@ -50,7 +50,7 @@ public:
template<class ForeignPointerType>
void on_belongs_to(const char *id, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/);
template<class ForeignPointerType>
void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/);
void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const char *join_column, const utils::foreign_attributes &/*attr*/);
template<class CollectionType>
void on_has_many(const char *id, CollectionType &,
const char *join_column,
@ -134,7 +134,7 @@ void foreign_node_completer<NodeType, Observers...>::on_belongs_to(const char *
template<typename NodeType, template<typename> typename ...Observers>
template<class ForeignPointerType>
void foreign_node_completer<NodeType, Observers...>::on_has_one(const char * /*id*/, ForeignPointerType &, const utils::foreign_attributes &) {
void foreign_node_completer<NodeType, Observers...>::on_has_one(const char * /*id*/, ForeignPointerType &, const char * /*join_column*/, const utils::foreign_attributes &) {
attach_node<typename ForeignPointerType::value_type>();
}

2
include/matador/object/join_columns_collector.hpp
View File

@ -34,7 +34,7 @@ public:
template<class Pointer>
static void on_belongs_to(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*obj*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(ContainerType &, const char */*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>

4
include/matador/object/object_generator.hpp
View File

@ -35,7 +35,7 @@ public:
template<class Pointer>
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
@ -92,7 +92,7 @@ public:
create_fk_constraint<typename Pointer::value_type>(id);
}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template <class Pointer>
void on_foreign_key(const char *id, Pointer &/*x*/) {

8
include/matador/object/object_resolver.hpp
View File

@ -2,6 +2,7 @@
#define MATADOR_OBJECT_LOADER_HPP
#include "matador/object/abstract_type_resolver.hpp"
#include "matador/object/abstract_joined_resolver.hpp"
#include <memory>
@ -17,5 +18,12 @@ public:
virtual std::shared_ptr<Type> resolve(const utils::identifier& id) = 0;
};
template<typename Type>
class joined_object_resolver : public abstract_joined_resolver {
public:
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;
};
}
#endif //MATADOR_OBJECT_LOADER_HPP

2
include/matador/object/pk_field_locator.hpp
View File

@ -119,7 +119,7 @@ struct pk_field_locator {
template <typename Pointer>
static void on_belongs_to(const char *, Pointer &, const utils::foreign_attributes &) {}
template <typename Pointer>
static void on_has_one(const char *, Pointer &, const utils::foreign_attributes &) {}
static void on_has_one(const char *, Pointer &, const char * /*join_column*/, const utils::foreign_attributes &) {}
template <typename Container>
static void on_has_many(const char *, Container &, const char *, const utils::foreign_attributes &) {}
template <typename Container>

2
include/matador/object/primary_key_resolver.hpp
View File

@ -58,7 +58,7 @@ public:
template<class Pointer>
static void on_belongs_to(const char * /*id*/, Pointer &/*val*/, const utils::foreign_attributes &/*attr*/) {}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*val*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*val*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(const char * /*id*/, ContainerType &/*col*/, const char *, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>

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

@ -43,7 +43,7 @@ public:
found_ = requested_join_column_ == id;
}
template<class ForeignPointerType>
static void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class CollectionType>
static void on_has_many(const char * /*id*/, CollectionType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
@ -117,7 +117,7 @@ public:
template<class ForeignPointerType>
void on_belongs_to(const char *id, ForeignPointerType &obj, const utils::foreign_attributes &attr);
template<class ForeignPointerType>
void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/);
void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/);
template<class CollectionType>
void on_has_many(const char *id, CollectionType &, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> * = nullptr);
@ -280,6 +280,7 @@ template<typename Type, template<typename> typename... Observers>
template<class ForeignPointerType>
void relation_completer<Type, Observers...>::on_has_one(const char *id,
ForeignPointerType &/*obj*/,
const char * /*join_column*/,
const utils::foreign_attributes &/*attr*/) {
using value_type = typename ForeignPointerType::value_type;
const auto foreign_node = find_node(typeid(value_type));

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

@ -56,7 +56,7 @@ public:
template<class P>
static void on_belongs_to(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
template<class P>
static void on_has_one(const char * /*id*/, P &, const utils::foreign_attributes & ) {}
static void on_has_one(const char * /*id*/, P &, const char * /*join_column*/, const utils::foreign_attributes & ) {}
template<class C>
static void on_has_many(const char * /*id*/, C &, const char * /*join_column*/, const utils::foreign_attributes & ) {}
template<class C>
@ -103,6 +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;
protected:
template<typename Type>
@ -113,6 +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_;
};
}
#endif //MATADOR_BASIC_SCHEMA_HPP

8
include/matador/query/dependency_collector.hpp
View File

@ -89,16 +89,16 @@ struct dependency_collector {
}
template<class Pointer>
static void on_has_one(const char*, Pointer&, const auto&) {}
static void on_has_one(const char*, Pointer&, const char * /*join_column*/, const utils::foreign_attributes&) {}
template<class Container>
static void on_has_many(const char*, Container&, const char*, const auto&) {}
static void on_has_many(const char*, Container&, const char*, const utils::foreign_attributes&) {}
template<class Container>
static void on_has_many_to_many(const char*, Container&, const char*, const char*, const auto&) {}
static void on_has_many_to_many(const char*, Container&, const char*, const char*, const utils::foreign_attributes&) {}
template<class Container>
static void on_has_many_to_many(const char*, Container&, const auto&) {}
static void on_has_many_to_many(const char*, Container&, const utils::foreign_attributes&) {}
};
struct flush_node {

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

@ -37,7 +37,7 @@ public:
template<class Pointer>
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many_to_many(const char *, ContainerType &, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>

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

@ -81,7 +81,7 @@ public:
on_foreign_key(id, x, attr);
}
template<class Pointer>
void on_has_one(const char *id, Pointer &x, const utils::foreign_attributes &attr) {
void on_has_one(const char *id, Pointer &x, const char * /*join_column*/, const utils::foreign_attributes &attr) {
on_foreign_key(id, x, attr);
}
@ -189,7 +189,7 @@ public:
result_.emplace_back(utils::_);
}
template<class Type, template < class ... > class Pointer>
void on_has_one(const char * /*id*/, Pointer<Type> &/*x*/, const utils::foreign_attributes &/*attr*/) {
void on_has_one(const char * /*id*/, Pointer<Type> &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {
result_.emplace_back(utils::_);
}
template<class ContainerType>
@ -249,7 +249,7 @@ public:
push_back(id, fk_value_extractor_.extract(*x));
}
template<class Type, template < class ... > class Pointer>
void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/) {
void on_has_one(const char *id, Pointer<Type> &x, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {
push_back(id, fk_value_extractor_.extract(*x));
}
template<class ContainerType>

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

@ -43,7 +43,7 @@ public:
obj = ptr_;
}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*obj*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class CollectionType>
static void on_has_many(const char * /*id*/, CollectionType &/*con*/, const char *, const utils::foreign_attributes &/*attr*/, std::enable_if_t<!object::is_object_ptr<typename CollectionType::value_type>::value> * = nullptr) {}
template<class Collection>
@ -100,7 +100,7 @@ public:
}
template<class Pointer>
void on_has_one(const char * /*id*/, Pointer &obj, const utils::foreign_attributes &attr) {
void on_has_one(const char * /*id*/, Pointer &obj, const char * /*join_column*/, const utils::foreign_attributes &attr) {
on_foreign_object(obj, attr);
}
template<class CollectionType>

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

@ -44,7 +44,7 @@ public:
result_.emplace_back(id, fk_value_extractor_.extract(*x));
}
template<class Type, template < class ... > class Pointer>
void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/) {
void on_has_one(const char *id, Pointer<Type> &x, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {
result_.emplace_back(id, fk_value_extractor_.extract(*x));
}
template<class ContainerType>

41
include/matador/query/schema.hpp
View File

@ -41,6 +41,33 @@ private:
std::string pk_name_;
};
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)
: 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 {
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{});
}
private:
basic_schema& repo_;
const table& table_;
std::string pk_name_;
};
template<typename Type>
class query_collection_resolver_producer : public sql::collection_resolver_producer {
public:
@ -64,7 +91,7 @@ public:
return utils::ok(stmt);
}
std::shared_ptr<object::abstract_collection_resolver> produce(sql::statement&& stmt, const sql::resolver_service& rs) override {
std::shared_ptr<object::abstract_joined_resolver> produce(sql::statement&& stmt, const sql::resolver_service& rs) override {
const auto object_resolver = rs.object_resolver<typename Type::value_type>();
return std::make_shared<query_collection_resolver<Type>>(std::move(stmt), root_type(), collection_name(), object_resolver);
@ -99,7 +126,7 @@ public:
return utils::ok(stmt);
}
std::shared_ptr<object::abstract_collection_resolver> produce(sql::statement&& stmt, const sql::resolver_service& /*rs*/) override {
std::shared_ptr<object::abstract_joined_resolver> produce(sql::statement&& stmt, const sql::resolver_service& /*rs*/) override {
return std::make_shared<query_collection_primitive_resolver<Type>>(std::move(stmt), root_type(), collection_name()/*, object_resolver*/);
}
@ -126,7 +153,7 @@ public:
template<class Pointer>
static void on_belongs_to(const char * /*id*/, Pointer & /*x*/, const utils::foreign_attributes &/*attr*/) {}
template<class Pointer>
void on_has_one(const char * /*id*/, Pointer & /*x*/, const utils::foreign_attributes &/*attr*/) {
void on_has_one(const char * /*id*/, Pointer & /*x*/, const char *join_column, const utils::foreign_attributes &/*attr*/) {
const auto it = schema_.find(typeid(typename Pointer::value_type));
if (it == schema_.end()) {
throw query_builder_exception{error_code::UnknownType, "Unknown type"};
@ -135,8 +162,12 @@ public:
throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"};
}
auto producer = std::make_unique<query_object_resolver_producer<typename Pointer::value_type>>(schema_, it->second.table(), it->second.node().info().primary_key_attribute()->name());
schema_.resolver_producers_[typeid(typename Pointer::value_type)] = std::move(producer);
auto producer = std::make_unique<query_object_resolver_producer<typename Pointer::value_type>>(
schema_,
it->second.table(),
join_column);
const object::collection_composite_key key{root_type_, typeid(Pointer), join_column};
schema_.joined_object_resolver_producers_[key] = std::move(producer);
}
template<class CollectionType>

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

@ -117,7 +117,7 @@ public:
}
template<class Pointer>
void on_has_one(const char *id, Pointer &obj, const utils::foreign_attributes &attr) {
void on_has_one(const char *id, Pointer &obj, const char * /*join_column*/, const utils::foreign_attributes &attr) {
on_foreign_object(id, obj, attr, false);
}

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

@ -144,7 +144,7 @@ public:
template<class Pointer>
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(const char * /*id*/,

3
include/matador/query/value_extractor.hpp
View File

@ -44,8 +44,7 @@ public:
values_.emplace_back(fk_value_extractor_.extract(*x));
}
template<class Type, template < class ... > class Pointer>
void on_has_one(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/)
{
void on_has_one(const char * /*id*/, Pointer<Type> &x, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {
values_.emplace_back(fk_value_extractor_.extract(*x));
}
template<class ContainerType>

2
include/matador/sql/generator.hpp
View File

@ -68,7 +68,7 @@ public:
on_foreign_key(id, x, attr);
}
template<class Pointer>
void on_has_one(const char *id, Pointer &x, const utils::foreign_attributes &attr) {
void on_has_one(const char *id, Pointer &x, const char * /*join_column*/, const utils::foreign_attributes &attr) {
on_foreign_key(id, x, attr);
}

4
include/matador/sql/internal/collection_resolver_producer.hpp
View File

@ -1,7 +1,7 @@
#ifndef MATADOR_COLLECTION_RESOLVER_PRODUCER_HPP
#define MATADOR_COLLECTION_RESOLVER_PRODUCER_HPP
#include "matador/object/abstract_collection_resolver.hpp"
#include "matador/object/abstract_joined_resolver.hpp"
#include "matador/sql/query_context.hpp"
@ -18,7 +18,7 @@ class collection_resolver_producer {
public:
virtual ~collection_resolver_producer() = default;
virtual utils::result<query_context, utils::error> build_query(const dialect& d) = 0;
virtual std::shared_ptr<object::abstract_collection_resolver> produce(statement&& stmt, const resolver_service& rs) = 0;
virtual std::shared_ptr<object::abstract_joined_resolver> produce(statement&& stmt, const resolver_service& rs) = 0;
[[nodiscard]] const std::type_index& root_type() const;
[[nodiscard]] const std::type_index& type() const;

2
include/matador/sql/internal/identifier_reader.hpp
View File

@ -36,7 +36,7 @@ public:
template < class Pointer >
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
template < class Pointer >
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>

19
include/matador/sql/internal/object_resolver_producer.hpp
View File

@ -27,5 +27,24 @@ protected:
private:
std::type_index type_;
};
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;
[[nodiscard]] const std::type_index& root_type() const;
[[nodiscard]] const std::type_index& type() const;
[[nodiscard]] const std::string& collection_name() const;
protected:
explicit joined_object_resolver_producer(const std::type_index &root_type, const std::type_index &type, std::string collection_name);
private:
std::type_index root_type_;
std::type_index type_;
std::string collection_name_;
};
}
#endif //MATADOR_RESOLVER_PRODUCER_HPP

4
include/matador/sql/internal/object_result_binder.hpp
View File

@ -38,7 +38,7 @@ public:
template < class Pointer >
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
template < class Pointer >
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(const char * /*id*/,
@ -96,7 +96,7 @@ public:
fk_result_binder_.bind(*x, id, index_++, *binder_);
}
template<class Type, template < class ... > class Pointer>
void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/) {
void on_has_one(const char *id, Pointer<Type> &x, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {
fk_result_binder_.bind(*x, id, index_++, *binder_);
}
template<class ContainerType>

2
include/matador/sql/internal/pk_reader.hpp
View File

@ -32,7 +32,7 @@ public:
++column_index_;
}
template<class Pointer>
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(const char * /*id*/, ContainerType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>

55
include/matador/sql/internal/query_result_impl.hpp
View File

@ -63,15 +63,9 @@ public:
void on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr);
template<class Pointer>
void on_belongs_to(const char * /*id*/, Pointer &x, const utils::foreign_attributes &attr) {
on_foreign_key(x, attr);
}
template<class Pointer>
void on_has_one(const char * /*id*/, Pointer &x, const utils::foreign_attributes &attr) {
on_foreign_key(x, attr);
}
void on_belongs_to(const char * /*id*/, Pointer &x, const utils::foreign_attributes &attr);
template<class PointerType>
void on_has_one(const char * /*id*/, object::object_ptr<PointerType> &x, const char * /*join_column*/, const utils::foreign_attributes &attr);
template<class CollectionType>
void on_has_many(const char * /*id*/, CollectionType &cont, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<object::is_object_ptr<typename CollectionType::value_type>::value> * = nullptr);
template<class CollectionType>
@ -103,8 +97,22 @@ private:
return resolver.discover(obj);
}
protected:
size_t column_index_ = 0;
std::vector<object::attribute> prototype_;
std::unique_ptr<query_result_reader> reader_;
std::shared_ptr<resolver_service> resolver_;
const std::type_index result_type_;
internal::identifier_reader id_reader_;
detail::pk_reader pk_reader_;
std::stack<std::type_index> type_stack_;
utils::identifier current_pk_{};
utils::identifier last_pk_{};
std::unordered_set<object::collection_composite_key, object::collection_composite_key_hash> initialized_collections_;
};
template <class Pointer>
void on_foreign_key(Pointer &x, const utils::foreign_attributes &attr) {
void query_result_impl::on_belongs_to(const char*, Pointer& x, const utils::foreign_attributes& attr) {
const auto resolver = resolver_->object_resolver<typename Pointer::value_type>();
if (attr.fetch() == utils::fetch_type::Lazy) {
typename Pointer::value_type obj;
@ -120,19 +128,20 @@ private:
}
}
protected:
size_t column_index_ = 0;
std::vector<object::attribute> prototype_;
std::unique_ptr<query_result_reader> reader_;
std::shared_ptr<resolver_service> resolver_;
const std::type_index result_type_;
internal::identifier_reader id_reader_;
detail::pk_reader pk_reader_;
std::stack<std::type_index> type_stack_;
utils::identifier current_pk_{};
utils::identifier last_pk_{};
std::unordered_set<object::collection_composite_key, object::collection_composite_key_hash> initialized_collections_;
};
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);
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_++)));
} 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));
}
}
template <class CollectionType>
void query_result_impl::on_has_many(const char *, CollectionType &cont, const char *join_column, const utils::foreign_attributes &attr, std::enable_if_t<object::is_object_ptr<typename CollectionType::value_type>::value> *) {

15
include/matador/sql/internal/query_result_pk_resolver.hpp
View File

@ -16,7 +16,8 @@ namespace matador::sql::internal {
class query_result_pk_resolver final {
public:
explicit query_result_pk_resolver(query_result_reader &reader) : reader_(reader) {}
explicit query_result_pk_resolver(query_result_reader &reader)
: reader_(reader) {}
template<class Type>
utils::identifier discover(Type &obj) {
@ -38,16 +39,22 @@ public:
utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_++, value, attr.size());
pk_ = value;
}
void on_revision(const char * /*id*/, uint64_t &/*rev*/) { ++column_index_; }
void on_revision(const char * /*id*/, uint64_t &/*rev*/) {
++column_index_;
}
template < class Type >
void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/) { ++column_index_; }
void on_attribute(const char *id, const utils::value &x, const utils::field_attributes &attr);
template < class Pointer >
void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &attr) { on_foreign_key<typename Pointer::value_type>(attr.fetch() ); }
void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &attr) {
on_foreign_key<typename Pointer::value_type>(attr.fetch() );
}
template < class Pointer >
void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &attr) { on_foreign_key<typename Pointer::value_type>(attr.fetch() ); }
void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &attr) {
on_foreign_key<typename Pointer::value_type>(attr.fetch() );
}
template<class ContainerType>
static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}

1
include/matador/sql/object_parameter_binder.hpp
View File

@ -40,6 +40,7 @@ public:
template<class Type, template < class ... > class Pointer>
static void on_has_one(const char * /*id*/,
Pointer<Type> &/*x*/,
const char * /*join_column*/,
const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(const char * /*id*/,

2
include/matador/sql/object_pk_binder.hpp
View File

@ -30,7 +30,7 @@ public:
template < class Pointer >
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
template < class Pointer >
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many(const char * /*id*/,

19
include/matador/sql/producer_resolver_factory.hpp
View File

@ -3,7 +3,7 @@
#include <unordered_map>
#include "matador/object/abstract_collection_resolver.hpp"
#include "matador/object/abstract_joined_resolver.hpp"
#include "matador/object/object_resolver_factory.hpp"
#include "matador/object/collection_resolver_factory.hpp"
#include "matador/object/collection_utils.hpp"
@ -22,13 +22,24 @@ private:
class producer_collection_resolver_factory : public object::collection_resolver_factory {
public:
[[nodiscard]] std::shared_ptr<object::abstract_collection_resolver> acquire_collection_resolver(const std::type_index& root_type,
[[nodiscard]] std::shared_ptr<object::abstract_joined_resolver> acquire_collection_resolver(const std::type_index& root_type,
const std::type_index& element_type,
const std::string& collection_name) const override;
void register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) override;
void register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) override;
private:
std::unordered_map<object::collection_composite_key, std::shared_ptr<object::abstract_collection_resolver>, object::collection_composite_key_hash> resolvers_;
std::unordered_map<object::collection_composite_key, std::shared_ptr<object::abstract_joined_resolver>, object::collection_composite_key_hash> resolvers_;
};
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,
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;
private:
std::unordered_map<object::collection_composite_key, std::shared_ptr<object::abstract_joined_resolver>, object::collection_composite_key_hash> resolvers_;
};
}
#endif //MATADOR_RESOLVER_FACTORY_HPP

9
include/matador/sql/resolver_service.hpp
View File

@ -16,12 +16,19 @@ public:
return collection_resolver_factory_.resolver<Type>(root_type, collection_name);
}
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 {
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_collection_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);
private:
sql::producer_resolver_factory object_resolver_factory_;
sql::producer_collection_resolver_factory collection_resolver_factory_;
sql::producer_resolver_factory joined_object_resolver_factory_;
};
}
#endif // MATADOR_RESOLVER_SERVICE_HPP

8
include/matador/utils/access.hpp
View File

@ -53,13 +53,13 @@ void attribute(Operator &op, const char *id, std::optional<Type> &value, const u
}
template<class Operator, class Type>
void has_one(Operator &op, const char *id, Type &value, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
op.on_has_one(id, value, attr);
void belongs_to(Operator &op, const char *id, Type &value, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
op.on_belongs_to(id, value, attr);
}
template<class Operator, class Type>
void belongs_to(Operator &op, const char *id, Type &value, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
op.on_belongs_to(id, value, attr);
void has_one(Operator &op, const char *id, Type &value, const char *join_column, const utils::foreign_attributes &attr = utils::CascadeNoneFetchLazy) {
op.on_has_one(id, value, join_column, attr);
}
template<class Operator, class Type, template<class ...> class ContainerType>

6
include/matador/utils/primary_key_accessor.hpp
View File

@ -38,7 +38,7 @@ public:
template<class P>
static void on_belongs_to(const char * /*id*/, P &, const foreign_attributes & ) {}
template<class P>
static void on_has_one(const char * /*id*/, P &, const foreign_attributes & ) {}
static void on_has_one(const char * /*id*/, P &, const char * /*join_column*/, const foreign_attributes & ) {}
template<class C>
static void on_has_many(const char * /*id*/, C &, const char * /*join_column*/, const foreign_attributes & ) {}
template<class C>
@ -65,7 +65,7 @@ struct pk_unset_checker {
template<class P>
static void on_belongs_to(const char * /*id*/, P &, const foreign_attributes & ) {}
template<class P>
static void on_has_one(const char * /*id*/, P &, const foreign_attributes & ) {}
static void on_has_one(const char * /*id*/, P &, const char * /*join_column*/, const foreign_attributes & ) {}
template<class C>
static void on_has_many(const char * /*id*/, C &, const char * /*join_column*/, const foreign_attributes & ) {}
template<class C>
@ -89,7 +89,7 @@ struct primary_key_getter {
template<class P>
static void on_belongs_to(const char * /*id*/, P &, const foreign_attributes & ) {}
template<class P>
static void on_has_one(const char * /*id*/, P &, const foreign_attributes & ) {}
static void on_has_one(const char * /*id*/, P &, const char * /*join_column*/, const foreign_attributes & ) {}
template<class C>
static void on_has_many(const char * /*id*/, C &, const char * /*join_column*/, const foreign_attributes & ) {}
template<class C>

4
source/core/CMakeLists.txt
View File

@ -13,7 +13,7 @@ add_library(matador-core STATIC
../../include/matador/net/reactor.hpp
../../include/matador/net/select_fd_sets.hpp
../../include/matador/net/socket_interrupter.hpp
../../include/matador/object/abstract_collection_resolver.hpp
../../include/matador/object/abstract_joined_resolver.hpp
../../include/matador/object/abstract_type_resolver.hpp
../../include/matador/object/abstract_type_resolver_factory.hpp
../../include/matador/object/attribute.hpp
@ -92,7 +92,7 @@ add_library(matador-core STATIC
logger/log_manager.cpp
logger/logger.cpp
logger/rotating_file_sink.cpp
object/abstract_collection_resolver.cpp
object/abstract_joined_resolver.cpp
object/attribute.cpp
object/basic_object_info.cpp
object/basic_repository.cpp

23
source/core/object/abstract_collection_resolver.cpp
View File

@ -1,23 +0,0 @@
#include "matador/object/abstract_collection_resolver.hpp"
namespace matador::object {
const std::type_index& abstract_collection_resolver::root_type() const {
return root_type_;
}
const std::type_index& abstract_collection_resolver::type() const {
return type_;
}
const std::string& abstract_collection_resolver::collection_name() const {
return collection_name_;
}
abstract_collection_resolver::abstract_collection_resolver(const std::type_index& root_type, const std::type_index& type, std::string collection_name)
: root_type_(root_type)
, type_(type)
, collection_name_(std::move(collection_name)) {}
} // namespace matador::object

16
source/core/object/abstract_joined_resolver.cpp Normal file
View File

@ -0,0 +1,16 @@
#include "matador/object/abstract_collection_resolver.hpp"
namespace matador::object {
const std::type_index& abstract_joined_resolver::root_type() const {
return root_type_;
}
const std::string& abstract_joined_resolver::collection_name() const {
return collection_name_;
}
abstract_joined_resolver::abstract_joined_resolver(const std::type_index& root_type, const std::type_index& type, std::string collection_name)
: abstract_type_resolver(type)
, root_type_(root_type)
, collection_name_(std::move(collection_name)) {}
} // namespace matador::object

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

@ -145,6 +145,10 @@ const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::
return collection_resolver_producers_;
}
const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::object_resolver_producer>, object::collection_composite_key_hash>& basic_schema::joined_object_resolver_producers() const {
return joined_object_resolver_producers_;
}
namespace detail {
utils::result<void, utils::error> create_tables(const object::repository &repo, const sql::connection &conn) {
for (const auto &node: repo) {

17
source/orm/query/session.cpp
View File

@ -93,6 +93,23 @@ session::session(session_context&& ctx, const basic_schema &scm)
}
}
for (const auto &pair : schema_.joined_object_resolver_producers()) {
auto res = pair.second->build_query(dialect_).and_then([this](sql::query_context&& query_ctx) -> result<sql::statement, error> {
query_ctx.resolver = resolver_service_;
return cache_.acquire(query_ctx);
}).and_then([&pair, this](sql::statement&& stmt) -> result<void, error> {
resolver_service_->register_collection_resolver(pair.second->produce(std::move(stmt), *resolver_service_));
return ok<void>();
}).or_else([](const auto &err) {
return failure(err);
});
if (!res) {
throw std::runtime_error(res.err().message());
}
}
for (const auto &pair : schema_.collection_resolver_producers()) {
auto res = pair.second->build_query(dialect_).and_then([this](sql::query_context&& query_ctx) -> result<sql::statement, error> {
query_ctx.resolver = resolver_service_;

17
source/orm/sql/internal/object_resolver_producer.cpp
View File

@ -8,3 +8,20 @@ const std::type_index & object_resolver_producer::type() const {
object_resolver_producer::object_resolver_producer(const std::type_index &type)
: type_(type) {}
}
const std::type_index& matador::sql::joined_object_resolver_producer::root_type() const {
return root_type_;
}
const std::type_index& matador::sql::joined_object_resolver_producer::type() const {
return type_;
}
const std::string& matador::sql::joined_object_resolver_producer::collection_name() const {
return collection_name_;
}
matador::sql::joined_object_resolver_producer::joined_object_resolver_producer(const std::type_index& root_type, const std::type_index& type, std::string collection_name)
: root_type_(root_type)
, type_(type)
, collection_name_(std::move(collection_name)) {}

19
source/orm/sql/producer_resolver_factory.cpp
View File

@ -11,7 +11,7 @@ std::shared_ptr<object::abstract_type_resolver> producer_resolver_factory::acqui
void producer_resolver_factory::register_object_resolver(std::shared_ptr<object::abstract_type_resolver> &&resolver) {
resolvers_[resolver->type()] = std::move(resolver);
}
std::shared_ptr<object::abstract_collection_resolver>
std::shared_ptr<object::abstract_joined_resolver>
producer_collection_resolver_factory::acquire_collection_resolver(const std::type_index& root_type,
const std::type_index& element_type,
const std::string& collection_name) const {
@ -21,7 +21,22 @@ producer_collection_resolver_factory::acquire_collection_resolver(const std::typ
}
return nullptr;
}
void producer_collection_resolver_factory::register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) {
void producer_collection_resolver_factory::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
const object::collection_composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()};
resolvers_[key] = std::move(resolver);
}
std::shared_ptr<object::abstract_joined_resolver> producer_joined_object_resolver_factory::acquire_joined_object_resolver(const std::type_index& root_type,
const std::type_index& element_type,
const std::string& collection_name) const {
const object::collection_composite_key key{root_type, element_type, collection_name};
if (const auto it = resolvers_.find(key); it != resolvers_.end()) {
return it->second;
}
return nullptr;
}
void producer_joined_object_resolver_factory::register_joined_object_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
const object::collection_composite_key key{resolver->root_type(), resolver->type(), resolver->collection_name()};
resolvers_[key] = std::move(resolver);
}

7
source/orm/sql/resolver_service.cpp
View File

@ -4,7 +4,12 @@ namespace matador::sql {
void resolver_service::register_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver) {
object_resolver_factory_.register_object_resolver(std::move(resolver));
}
void resolver_service::register_collection_resolver(std::shared_ptr<object::abstract_collection_resolver>&& resolver) {
void resolver_service::register_collection_resolver(std::shared_ptr<object::abstract_joined_resolver>&& resolver) {
collection_resolver_factory_.register_collection_resolver(std::move(resolver));
}
void resolver_service::register_joined_object_resolver(std::shared_ptr<object::abstract_type_resolver>&& resolver) {
joined_object_resolver_factory_.register_object_resolver(std::move(resolver));
}
} // namespace matador::query

4
test/backends/SessionInsertHasOne.cpp
View File

@ -29,5 +29,7 @@ TEST_CASE_METHOD(SessionFixture, "Test insert object with has_one relation", "[s
REQUIRE(us.is_persistent());
REQUIRE(u.is_persistent());
REQUIRE(u->session->session_token == "session1");
const auto user_result = ses.find<user_identity>(u->id);
REQUIRE(user_result.is_ok());
REQUIRE(user_result.value()->session->session_token == "session1");
}

2
test/models/user.hpp
View File

@ -31,7 +31,7 @@ struct user_pk_generator {
field::primary_key(op, "id", id, PkAttribute);
field::attribute(op, "name", name, UniqueVarChar255);
field::attribute(op, "password", password, UniqueVarChar255);
field::has_one(op, "session", session, CascadeAllFetchLazy);
field::has_one(op, "session", session, "user_id", CascadeAllFetchLazy);
}
};