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

relation completer progress

Browse Source
This commit is contained in:
sascha
2025-07-06 20:06:26 +02:00
parent 5c1e0ae0d8
commit c974628bee
11 changed files with 358 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/matador/object/basic_object_info.hpp
+2 -2
View File
@@ -16,7 +16,7 @@ class relation_endpoint;
class basic_object_info {
public:
using t_endpoint_map = std::unordered_map<std::type_index, relation_endpoint>;
using t_endpoint_map = std::unordered_map<std::type_index, std::shared_ptr<relation_endpoint>>;
using endpoint_iterator = t_endpoint_map::iterator;
using const_endpoint_iterator = t_endpoint_map::const_iterator;
@@ -30,7 +30,7 @@ public:
[[nodiscard]] bool has_primary_key() const;
[[nodiscard]] const utils::identifier& primary_key() const;
void register_relation_endpoint(const std::type_index &type, const relation_endpoint &endpoint);
void register_relation_endpoint(const std::type_index &type, const std::shared_ptr<relation_endpoint> &endpoint);
void unregister_relation_endpoint(const std::type_index &type);
[[nodiscard]] const_endpoint_iterator find_relation_endpoint(const std::type_index &type) const;
include/matador/object/relation_endpoint.hpp
+5
View File
@@ -3,6 +3,7 @@
#include "matador/utils/enum_mapper.hpp"
#include <cstdint>
#include <memory>
namespace matador::object {
@@ -27,6 +28,7 @@ public:
[[nodiscard]] std::string field_name() const;
[[nodiscard]] relation_type type() const;
[[nodiscard]] std::string type_name() const;
[[nodiscard]] const schema_node& node() const;
[[nodiscard]] bool is_has_one() const;
@@ -37,6 +39,9 @@ public:
void link_foreign_endpoint(const std::shared_ptr<relation_endpoint>& endpoint);
private:
template<typename>
friend class relation_completer;
std::string field_name_;
relation_type type_;
std::shared_ptr<schema_node> node_;
include/matador/object/schema.hpp
+225 -141
View File
@@ -19,8 +19,7 @@
#include <unordered_set>
namespace matador::object {
utils::error make_error(error_code ec, const std::string& msg);
utils::error make_error(error_code ec, const std::string &msg);
class schema;
@@ -60,6 +59,7 @@ template<typename Type>
class relation_completer final {
public:
using value_type = Type;
using endpoint_ptr = std::shared_ptr<relation_endpoint>;
static void complete(const std::shared_ptr<schema_node> &node) {
relation_completer completer(node);
@@ -68,16 +68,27 @@ public:
access::process(completer, obj);
}
template < class PrimaryKeyType >
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>>* = nullptr) {}
static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
template<class PrimaryKeyType>
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/,
std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool,
PrimaryKeyType>> * = nullptr) {
}
static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {
}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {
}
template<typename AttributeType>
static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
static void on_attribute(const char * /*id*/, AttributeType &/*val*/,
const utils::field_attributes &/*attr*/ = utils::null_attributes) {
}
template<typename AttributeType>
static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
static void on_attribute(const char * /*id*/, std::optional<AttributeType> &/*val*/,
const utils::field_attributes &/*attr*/ = utils::null_attributes) {
}
template<class ForeignPointerType>
void on_belongs_to(const char *id, ForeignPointerType &obj, const utils::foreign_attributes &attr);
@@ -85,44 +96,53 @@ public:
void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, 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 );
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);
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 );
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);
template<class CollectionType>
void on_has_many_to_many(const char *id, CollectionType &collection, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr);
void on_has_many_to_many(const char *id, CollectionType &collection, const char *join_column,
const char *inverse_join_column, const utils::foreign_attributes &attr);
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &collection, const utils::foreign_attributes &attr);
private:
explicit relation_completer(const std::shared_ptr<schema_node>& node)
: node_(node)
, schema_(node->schema_)
, log_(logger::create_logger("relation_completer")) {}
explicit relation_completer(const std::shared_ptr<schema_node> &node)
: node_(node)
, schema_(node->schema_)
, log_(logger::create_logger("relation_completer")) {
}
static void register_relation_endpoints(const endpoint_ptr &endpoint,
const endpoint_ptr &other_endpoint);
static void link_relation_endpoints(const endpoint_ptr &endpoint,
const endpoint_ptr &other_endpoint);
private:
std::shared_ptr<schema_node> node_;
schema& schema_;
schema &schema_;
logger::logger log_;
};
class schema {
public:
typedef const_schema_node_iterator const_iterator; /**< Shortcut for the list const iterator. */
typedef const_schema_node_iterator const_iterator; /**< Shortcut for the list const iterator. */
using node_ptr = std::shared_ptr<schema_node>;
/**
* Creates an empty schema
*/
explicit schema( std::string name = "");
explicit schema(std::string name = "");
template <typename Type>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string& name, const std::string &parent = "") {
template<typename Type>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, const std::string &parent = "") {
// if (has_node(name)) {
// return utils::failure(make_error(error_code::NodeAlreadyExists, "Node '" + name + "' already exists"));
// return utils::failure(make_error(error_code::NodeAlreadyExists, "Node '" + name + "' already exists"));
// }
auto node = acquire_node<Type>(name);
log_.info("attach node %s", name.c_str());
relation_completer<Type>::complete(node);
if (auto result = attach_node(node, parent); !result) {
return utils::failure(result.err());
@@ -131,17 +151,22 @@ public:
return utils::ok<void>();
}
template <typename Type, typename SuperType>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string name) {
template<typename Type, typename SuperType>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name) {
const auto ti = std::type_index(typeid(SuperType));
auto result = find_node(ti);
if (!result) {
return utils::failure(make_error(error_code::NodeNotFound, "Parent node '" + std::string(ti.name()) + "' not found"));
return utils::failure(make_error(error_code::NodeNotFound,
"Parent node '" + std::string(ti.name()) + "' not found"));
}
return attach<Type>(name, (*result)->name());
}
[[nodiscard]] utils::result<void, utils::error> detach(const node_ptr& node);
// [[nodiscard]] utils::result<void, utils::error> detach(const std::string& name);
/**
* Return the first schema node.
*
@@ -178,42 +203,44 @@ public:
*/
[[nodiscard]] std::string name() const;
template <typename Type>
template<typename Type>
[[nodiscard]] utils::result<object_info_ref<Type>, utils::error> info() const {
auto result = find_node(std::type_index(typeid(Type)));
if (!result) {
return utils::failure(result.err());
}
auto result = find_node(std::type_index(typeid(Type)));
if (!result) {
return utils::failure(result.err());
}
return utils::ok(result.value()->info<Type>());
return utils::ok(result.value()->info<Type>());
}
template <typename Type>
template<typename Type>
[[nodiscard]] utils::result<basic_object_info_ref, utils::error> basic_info() const {
auto result = find_node(std::type_index(typeid(Type)));
if (!result) {
return utils::failure(result.err());
}
auto result = find_node(std::type_index(typeid(Type)));
if (!result) {
return utils::failure(result.err());
}
return utils::ok(basic_object_info_ref{result.value()->info()});
return utils::ok(basic_object_info_ref{result.value()->info()});
}
[[nodiscard]] utils::result<std::shared_ptr<attribute_definition>, utils::error> reference(const std::type_index &type_index) const;
[[nodiscard]] utils::result<std::shared_ptr<attribute_definition>, utils::error> reference(
const std::type_index &type_index) const;
void dump(std::ostream &os) const;
private:
using node_ptr = std::shared_ptr<schema_node>;
using t_node_map = std::unordered_map<std::string, node_ptr>;
using t_type_index_node_map = std::unordered_map<std::type_index, node_ptr>;
[[nodiscard]] utils::result<std::shared_ptr<schema_node>, utils::error> attach_node(const std::shared_ptr<schema_node> &node,
const std::string &parent);
[[nodiscard]] utils::result<std::shared_ptr<schema_node>, utils::error> attach_node(const std::shared_ptr<schema_node> &node,
const std::type_index &type_index);
[[nodiscard]] utils::result<std::shared_ptr<schema_node>, utils::error> find_node(const std::string &name) const;
[[nodiscard]] utils::result<std::shared_ptr<schema_node>, utils::error> find_node(const std::type_index &type_index) const;
[[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const std::shared_ptr<schema_node> &node,
const std::string &parent);
[[nodiscard]] utils::result<node_ptr, utils::error> attach_node(const std::shared_ptr<schema_node> &node,
const std::type_index &type_index);
[[nodiscard]] utils::result<node_ptr, utils::error> find_node(const std::string &name) const;
[[nodiscard]] utils::result<node_ptr, utils::error> find_node(const std::type_index &type_index) const;
template <typename Type>
std::shared_ptr<schema_node> acquire_node(const std::string& name) {
template<typename Type>
node_ptr acquire_node(const std::string &name) {
if (const auto it = expected_node_map_.find(typeid(Type)); it != expected_node_map_.end()) {
const auto node = it->second;
expected_node_map_.erase(it);
@@ -227,13 +254,14 @@ private:
[[nodiscard]] bool has_node(const std::string &name) const;
[[nodiscard]] bool has_node(const std::type_index& index) const;
[[nodiscard]] bool has_node(const std::type_index& index, const std::string &name) const;
[[nodiscard]] bool has_node(const std::type_index &index) const;
[[nodiscard]] bool has_node(const std::type_index &index, const std::string &name) const;
static void push_back_child(const node_ptr &parent, const node_ptr &child);
void remove_node(const node_ptr &node);
private:
template <typename Type>
template<typename Type>
friend class relation_completer;
std::string name_;
@@ -247,124 +275,180 @@ private:
template<typename Type>
template<class CollectionType>
void relation_completer<Type>::on_has_many( const char *id, CollectionType&,
const char *join_column,
const utils::foreign_attributes&,
std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value>* /*unused*/ ) {
using value_type = typename CollectionType::value_type::value_type;
void relation_completer<Type>::on_has_many(const char *id, CollectionType &,
const char *join_column,
const utils::foreign_attributes &,
std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> *
/*unused*/) {
using value_type = typename CollectionType::value_type::value_type;
// Check if the object_ptr type is already inserted in the schema (by id)
if (auto result = schema_.find_node(id); !result) {
// Type was not found.
// Create and attach the relation node.
const std::type_index ti = typeid(many_to_many_relation<value_type, Type>);
const auto endpoint = node_->info().find_relation_endpoint(ti);
if (endpoint == node_->info().endpoint_end()) {
// Endpoint was not found
log_.debug("node '%s' has has many foreign keys '%s' mapped by '%s'", node_->name().c_str(), id, join_column);
const auto node = schema_node::make_relation_node<many_to_many_relation<value_type, Type> >(
schema_, id, [join_column] {
return std::make_unique<many_to_many_relation<value_type, Type> >(join_column, "id");
});
result = schema_.attach_node(node, "");
if (!result) {
// Todo: throw internal error
return;
}
const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
const auto foreign_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, node);
node_->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
foreign_endpoint->node_->info_->register_relation_endpoint(node_->type_index(), foreign_endpoint);
link_relation_endpoints(local_endpoint, foreign_endpoint);
// Check if the object_ptr type is already inserted in the schema (by id)
if (auto result = schema_.find_node(id); !result) {
const std::type_index ti = typeid(many_to_many_relation<value_type, Type>);
const auto endpoint = node_->info().find_relation_endpoint(ti);
if (endpoint == node_->info().endpoint_end()) {
log_.debug("node '%s' has has many foreign keys '%s' mapped by '%s'", node_->name().c_str(), id, join_column);
const auto node = schema_node::make_relation_node<many_to_many_relation<value_type, Type>>(schema_, id, [join_column] {
return std::make_unique<many_to_many_relation<value_type, Type>>(join_column, "id");
});
log_.debug("node '%s' many to many type: %s", node_->name().c_str(), typeid(many_to_many_relation<value_type, Type>).name());
result = schema_.attach_node(node, "");
if (!result) {
// Todo: throw internal error
return;
}
node_->info_->register_relation_endpoint(node->type_index(), relation_endpoint(id, relation_type::BELONGS_TO, node));
node->info_->register_relation_endpoint(node_->type_index(), relation_endpoint(id, relation_type::HAS_MANY, node_));
}
} else {
}
} else {
// Type was found.
// Check if the relation node is already attached.
const auto &foreign_node = result.value();
if (const auto rit = foreign_node->info_->find_relation_endpoint(node_->type_index()); rit != foreign_node->info().endpoint_end()) {
if (rit->second->is_belongs_to()) {
rit->second->node_ = foreign_node;
const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
node_->info_->register_relation_endpoint(node_->type_index(), endpoint);
link_relation_endpoints(endpoint, rit->second);
} else {
// Todo: throw internal error relation node has invalid type
}
} else {
// Todo: throw internal error couldn't find relation node
}
}
}
template<typename Type>
template<class CollectionType>
void relation_completer<Type>::on_has_many( const char *id, CollectionType&, const char *join_column, const utils::foreign_attributes&, std::enable_if_t<!is_object_ptr<typename CollectionType::value_type>::value>* /*unused*/ ) {
using value_type = typename CollectionType::value_type;
void relation_completer<Type>::on_has_many(const char *id, CollectionType &, const char *join_column,
const utils::foreign_attributes &,
std::enable_if_t<!is_object_ptr<typename CollectionType::value_type>::value>
* /*unused*/) {
using value_type = typename CollectionType::value_type;
const auto node = schema_node::make_relation_node<many_to_many_relation<value_type, Type>>(schema_, id, [join_column] {
return new many_to_many_relation<value_type, Type>(join_column, "value");
const auto node = schema_node::make_relation_node<many_to_many_relation<value_type, Type> >(
schema_, id, [join_column] {
return new many_to_many_relation<value_type, Type>(join_column, "value");
});
const auto result = schema_.attach<many_to_relation<Type, value_type>>(id);
if (!result) {
// Todo: throw internal exception
}
const auto result = schema_.attach<many_to_relation<Type, value_type> >(id);
if (!result) {
// Todo: throw internal exception
}
}
template<typename Type>
template<class CollectionType>
void relation_completer<Type>::on_has_many_to_many( const char *id, CollectionType &/*collection*/, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &attr) {
auto result = schema_.find_node(id);
if (result) {
} else {
//
using relation_type = many_to_many_relation<typename CollectionType::value_type, Type>;
auto creator = [join_column, inverse_join_column] {
return new many_to_many_relation<typename CollectionType::value_type, Type>(join_column, inverse_join_column);
};
void relation_completer<Type>::on_has_many_to_many(const char *id, CollectionType &/*collection*/,
const char *join_column,
const char *inverse_join_column,
const utils::foreign_attributes &attr) {
auto result = schema_.find_node(id);
if (result) {
} else {
//
// using relation_type = many_to_many_relation<typename CollectionType::value_type, Type>;
// auto creator = [join_column, inverse_join_column] {
// return new many_to_many_relation<typename CollectionType::value_type, Type>(join_column, inverse_join_column);
// };
// auto node = schema_node::make_relation_node<relation_type>(schema_, id);
// auto node = schema_node::make_relation_node<relation_type>(schema_, id);
// schema_.attach_node(node, typeid(relation_type));
}
// schema_.attach_node(node, typeid(relation_type));
}
}
template<typename Type>
template<class ContainerType>
void relation_completer<Type>::on_has_many_to_many( const char *id, ContainerType &collection, const utils::foreign_attributes &attr ) {
auto result = schema_.find_node(id);
if (!result) {
using relation_type = many_to_many_relation<typename ContainerType::value_type, Type>;
// auto creator = [attr] {
// return new relation_type(attr.join_column, attr.inverse_join_column);
// };
}
}
template<typename Type>
template<class ForeignPointerType>
void relation_completer<Type>::on_has_one(const char * id, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/) {
auto endpoint = std::make_shared<relation_endpoint>(std::string(id), relation_type::HAS_ONE, std::shared_ptr<schema_node>());
auto ti = std::type_index(typeid(typename ForeignPointerType::value_type));
if (const auto result = schema_.find_node(ti); !result.is_ok() && schema_.expected_node_map_.count(ti) == 0) {
schema_.expected_node_map_.insert({ti, schema_node::make_node<typename ForeignPointerType::value_type>(schema_, ti.name())});
} else {
const auto& foreign_node = result.value();
if (const auto rit = foreign_node->info().find_relation_endpoint(ti); rit != foreign_node->info().endpoint_end()) {
if (rit->second.is_has_many()) {
} else if (rit->second.is_has_one()) {
} else {
}
}
void relation_completer<Type>::on_has_many_to_many(const char *id, ContainerType &collection,
const utils::foreign_attributes &attr) {
auto result = schema_.find_node(id);
if (!result) {
// using relation_type = many_to_many_relation<typename ContainerType::value_type, Type>;
// auto creator = [attr] {
// return new relation_type(attr.join_column, attr.inverse_join_column);
// };
}
}
template<typename Type>
template<class ForeignPointerType>
void relation_completer<Type>::on_belongs_to(const char* id, ForeignPointerType& /*obj*/, const utils::foreign_attributes& /*attr*/) {
auto ti = std::type_index(typeid(typename ForeignPointerType::value_type));
if (auto result = schema_.find_node(ti); !result) {
log_.debug("node '%s' has foreign key '%s' belongs to '%s'", node_->name().c_str(), id, typeid(typename ForeignPointerType::value_type).name());
} else {
const auto foreign_node = result.value();
auto it = foreign_node->info().find_relation_endpoint(node_->type_index());
if (it != foreign_node->info().endpoint_end()) {
auto endpoint = it->second;
}
using TP = many_to_many_relation<typename ForeignPointerType::value_type, Type>;
log_.debug("node '%s', many to many type: %s", node_->name().c_str(), typeid(TP).name());
log_.debug("foreign node '%s', many to many type: %s", foreign_node->name().c_str(), ti.name());
if (foreign_node->type_index() == ti) {
log_.debug("node '%s' has foreign key '%s' belongs to '%s': already inserted", node_->name().c_str(), id, result.value()->name().c_str());
} else {
}
void relation_completer<Type>::on_has_one(const char *id, ForeignPointerType &/*obj*/,
const utils::foreign_attributes &/*attr*/) {
auto ti = std::type_index(typeid(typename ForeignPointerType::value_type));
if (const auto result = schema_.find_node(ti); !result.is_ok() && schema_.expected_node_map_.count(ti) == 0) {
schema_.expected_node_map_.insert({
ti, schema_node::make_node<typename ForeignPointerType::value_type>(schema_, ti.name())
});
} else {
const auto &foreign_node = result.value();
if (const auto rit = foreign_node->info().find_relation_endpoint(ti); rit != foreign_node->info().endpoint_end()) {
if (rit->second->is_has_many()) {
} else if (rit->second->is_has_one()) {
} else {
}
}
}
}
template<typename Type>
template<class ForeignPointerType>
void relation_completer<Type>::on_belongs_to(const char *id, ForeignPointerType & /*obj*/,
const utils::foreign_attributes & /*attr*/) {
using value_type = typename ForeignPointerType::value_type;
const auto ti = std::type_index(typeid(value_type));
if (auto result = schema_.find_node(ti); !result) {
// Type was not found
// Create node without the foreign relation endpoint
log_.debug("node '%s' has foreign key '%s' belongs to '%s'", node_->name().c_str(), id, ti.name());
node_->info_->register_relation_endpoint(ti, std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, schema::node_ptr{}));
} else {
// Type was found
const auto& foreign_node = result.value();
// Check foreign node and relation endpoint
if (const auto it = foreign_node->info_->find_relation_endpoint(typeid(Type)); it != foreign_node->info().endpoint_end()) {
// Found corresponding relation endpoint in the foreign node
if (it->second->foreign_endpoint()->node().type_index() == typeid(many_to_many_relation<Type, value_type>)) {
// Endpoint is a "many_to_many_relation". This means there
// is a "many_to_many_relation" node attached. Because of being a
// "belongs_to"-relation the "many_to_many_relation" can be removed
// (detach), and the endpoints must be adjusted
const auto foreign_endpoint = it->second->foreign_endpoint();
const auto detach_result = schema_.detach(foreign_endpoint->node_);
foreign_endpoint->node_ = node_;
node_->info_->register_relation_endpoint(node_->type_index(), foreign_endpoint);
} else {
// check type
}
} else {
// Relation node was not found, create endpoint.
const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, node_);
node_->info_->register_relation_endpoint(ti, endpoint);
link_relation_endpoints(endpoint, it->second);
}
}
}
template<typename Type>
void relation_completer<Type>::register_relation_endpoints(const endpoint_ptr &endpoint, const endpoint_ptr &other_endpoint) {
endpoint->node_->info_->register_relation_endpoint(other_endpoint->node_->type_index(), endpoint);
other_endpoint->node_->info_->register_relation_endpoint(endpoint->node_->type_index(), other_endpoint);
link_relation_endpoints(endpoint, other_endpoint);
}
template<typename Type>
void relation_completer<Type>::link_relation_endpoints(const endpoint_ptr &endpoint, const endpoint_ptr &other_endpoint) {
endpoint->link_foreign_endpoint(other_endpoint);
other_endpoint->link_foreign_endpoint(endpoint);
}
}
#endif //SCHEMA_HPP
include/matador/object/schema_node.hpp
+4
View File
@@ -73,10 +73,14 @@ public:
[[nodiscard]] const object::schema& schema() const;
[[nodiscard]] bool has_children() const;
private:
explicit schema_node(object::schema& tree);
schema_node(object::schema& tree, std::string name);
void unlink();
private:
friend class schema;
template <typename Type>