relation completer progress
This commit is contained in:
parent
5c1e0ae0d8
commit
c974628bee
|
|
@ -5,20 +5,19 @@
|
|||
#include "author.hpp"
|
||||
#include "book.hpp"
|
||||
|
||||
#include <iostream>
|
||||
|
||||
/*
|
||||
* node author
|
||||
*
|
||||
* relation_endpoints
|
||||
* 1. - field_name "books"
|
||||
* - type_index <book>
|
||||
* - type "has_many"
|
||||
* - node <author>
|
||||
* - foreign endpoint (1) "author"
|
||||
*
|
||||
* node book
|
||||
* 2. - field_name "author_id"
|
||||
* - type_index <author>
|
||||
* - type "belongs_to"
|
||||
* - node <book>
|
||||
* - foreign endpoint (2) "books"
|
||||
|
|
@ -32,29 +31,50 @@
|
|||
* - create node many_to_many_relation<author, book>("author_id", "id")
|
||||
* - 3. create endpoint
|
||||
* - field name "author_id"
|
||||
* - type_index <author>
|
||||
* - type "belongs_to"
|
||||
* - node <many_to_many_relation<author, book>>
|
||||
* - foreign endpoint (1) "author
|
||||
* - set foreign endpoint of (1) to endpoint (3)
|
||||
* - register endpoint in authors node by type book
|
||||
* - attach (internal) node<many_to_many_relation<author, book>>
|
||||
*
|
||||
* attach<book>
|
||||
* - relation completer detects "belongs_to<author>"
|
||||
* - belongs_to<author> finds <book>
|
||||
* - try to find relation endpoint of type book in authors node
|
||||
* - if endpoint was found
|
||||
* - validate node in endpoint
|
||||
* - if node is of type many_to_many_relation
|
||||
* - detach node of endpoint
|
||||
* - update node in endpoint to <book>
|
||||
* - else
|
||||
* - create endpoint <book> (1)
|
||||
* - create endpoint <author> (2)
|
||||
* - set foreign endpoint of (1) to endpoint (2)
|
||||
* - set foreign endpoint of (2) to endpoint (1)
|
||||
* - check relation endpoints...
|
||||
*
|
||||
*
|
||||
*
|
||||
*/
|
||||
using namespace demo;
|
||||
using namespace matador;
|
||||
|
||||
int main() {
|
||||
logger::default_min_log_level(logger::log_level::LVL_DEBUG);
|
||||
logger::add_log_sink(logger::create_stdout_sink());
|
||||
|
||||
{
|
||||
object::schema schema;
|
||||
|
||||
auto result = schema.attach<author>("authors")
|
||||
.and_then([&schema] { return schema.attach<book>("books"); });
|
||||
|
||||
schema.dump(std::cout);
|
||||
}
|
||||
{
|
||||
object::schema schema;
|
||||
|
||||
auto result = schema.attach<book>("books")
|
||||
.and_then([&schema] { return schema.attach<author>("authors"); });
|
||||
|
||||
schema.dump(std::cout);
|
||||
}
|
||||
}
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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_;
|
||||
|
|
|
|||
|
|
@ -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,24 +96,32 @@ 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)
|
||||
explicit relation_completer(const std::shared_ptr<schema_node> &node)
|
||||
: node_(node)
|
||||
, schema_(node->schema_)
|
||||
, log_(logger::create_logger("relation_completer")) {}
|
||||
, 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_;
|
||||
};
|
||||
|
||||
|
|
@ -111,18 +130,19 @@ class schema {
|
|||
public:
|
||||
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"));
|
||||
// }
|
||||
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,7 +203,7 @@ 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) {
|
||||
|
|
@ -188,7 +213,7 @@ public:
|
|||
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) {
|
||||
|
|
@ -198,22 +223,24 @@ public:
|
|||
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,
|
||||
[[nodiscard]] utils::result<node_ptr, 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,
|
||||
[[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<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> 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,44 +275,71 @@ private:
|
|||
|
||||
template<typename Type>
|
||||
template<class CollectionType>
|
||||
void relation_completer<Type>::on_has_many( const char *id, 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*/ ) {
|
||||
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");
|
||||
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_));
|
||||
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);
|
||||
|
||||
}
|
||||
} 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*/ ) {
|
||||
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] {
|
||||
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);
|
||||
const auto result = schema_.attach<many_to_relation<Type, value_type> >(id);
|
||||
if (!result) {
|
||||
// Todo: throw internal exception
|
||||
}
|
||||
|
|
@ -292,15 +347,18 @@ void relation_completer<Type>::on_has_many( const char *id, CollectionType&, con
|
|||
|
||||
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) {
|
||||
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);
|
||||
};
|
||||
// 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);
|
||||
|
||||
|
|
@ -310,61 +368,87 @@ void relation_completer<Type>::on_has_many_to_many( const char *id, CollectionTy
|
|||
|
||||
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 ) {
|
||||
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>;
|
||||
// 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>());
|
||||
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())});
|
||||
schema_.expected_node_map_.insert({
|
||||
ti, schema_node::make_node<typename ForeignPointerType::value_type>(schema_, ti.name())
|
||||
});
|
||||
} else {
|
||||
const auto& foreign_node = result.value();
|
||||
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()) {
|
||||
|
||||
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*/) {
|
||||
auto ti = std::type_index(typeid(typename ForeignPointerType::value_type));
|
||||
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) {
|
||||
log_.debug("node '%s' has foreign key '%s' belongs to '%s'", node_->name().c_str(), id, typeid(typename ForeignPointerType::value_type).name());
|
||||
// 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 {
|
||||
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;
|
||||
// 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
|
||||
}
|
||||
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 {
|
||||
// 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
|
||||
|
|
|
|||
|
|
@ -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>
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
#include "matador/logger/basic_file_sink.hpp"
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
namespace matador::logger {
|
||||
|
||||
basic_file_sink::basic_file_sink(FILE *f)
|
||||
|
|
|
|||
|
|
@ -100,7 +100,7 @@ void log_domain::log(log_level lvl, const std::string &source, const char *messa
|
|||
#ifdef _MSC_VER
|
||||
int ret = sprintf_s(buffer, 1024, "%s [Thread %zu] [%-7s] [%s]: %s\n", timestamp, details::acquire_thread_index(std::this_thread::get_id()), level_strings[lvl].c_str(), source.c_str(), message);
|
||||
#else
|
||||
int ret = sprintf(buffer, "%s [Thread %lu] [%-7s] [%s]: %s\n", timestamp, acquire_thread_index(std::this_thread::get_id()), level_strings[lvl].c_str(), source.c_str(), message);
|
||||
int ret = sprintf(buffer, "%s [Thread %lu] [%-7s] [%s]: %s\n", timestamp, details::acquire_thread_index(std::this_thread::get_id()), level_strings[lvl].c_str(), source.c_str(), message);
|
||||
#endif
|
||||
|
||||
std::lock_guard<std::mutex> l(mutex_);
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ const utils::identifier& basic_object_info::primary_key() const {
|
|||
return identifier_.value();
|
||||
}
|
||||
|
||||
void basic_object_info::register_relation_endpoint(const std::type_index &type, const relation_endpoint &endpoint) {
|
||||
void basic_object_info::register_relation_endpoint(const std::type_index &type, const std::shared_ptr<relation_endpoint> &endpoint) {
|
||||
relation_endpoints_.insert(std::make_pair(type, endpoint));
|
||||
}
|
||||
|
||||
|
|
@ -77,13 +77,13 @@ basic_object_info::endpoint_iterator basic_object_info::find_relation_endpoint(c
|
|||
|
||||
basic_object_info::const_endpoint_iterator basic_object_info::find_relation_endpoint(const std::string &field) const {
|
||||
return std::find_if(relation_endpoints_.begin(), relation_endpoints_.end(), [&field](const t_endpoint_map::value_type &value) {
|
||||
return value.second.field_name() == field;
|
||||
return value.second->field_name() == field;
|
||||
});
|
||||
}
|
||||
|
||||
basic_object_info::endpoint_iterator basic_object_info::find_relation_endpoint(const std::string &field) {
|
||||
return std::find_if(relation_endpoints_.begin(), relation_endpoints_.end(), [&field](const t_endpoint_map::value_type &value) {
|
||||
return value.second.field_name() == field;
|
||||
return value.second->field_name() == field;
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -17,6 +17,10 @@ relation_type relation_endpoint::type() const {
|
|||
return type_;
|
||||
}
|
||||
|
||||
std::string relation_endpoint::type_name() const {
|
||||
return relation_type_enum.to_string(type_);
|
||||
}
|
||||
|
||||
const schema_node &relation_endpoint::node() const {
|
||||
return *node_;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,6 +17,33 @@ root_->first_child_->next_sibling_ = root_->last_child_;
|
|||
root_->last_child_->previous_sibling_ = root_->first_child_;
|
||||
}
|
||||
|
||||
utils::result<void, utils::error> schema::detach(const node_ptr &node) {
|
||||
log_.debug("detach node '%s' (type: %s)", node->name().c_str(), node->type_index().name());
|
||||
|
||||
remove_node(node);
|
||||
|
||||
return utils::ok<void>();
|
||||
}
|
||||
|
||||
// utils::result<void, utils::error> schema::detach(const std::string& name) {
|
||||
// const auto nit = nodes_by_name_.find(name);
|
||||
// if (nit == nodes_by_name_.end()) {
|
||||
// return utils::failure(make_error(error_code::NodeNotFound, "Node '" + name + "' not found."));
|
||||
// }
|
||||
//
|
||||
// const auto ti = nit->second->type_index();
|
||||
// nodes_by_name_.erase(nit);
|
||||
//
|
||||
// const auto it = nodes_by_type_.find(ti);
|
||||
// if (it == nodes_by_type_.end()) {
|
||||
// return utils::failure(make_error(error_code::NodeNotFound, "Node '" + name + "' not found."));
|
||||
// }
|
||||
//
|
||||
// nodes_by_type_.erase(it);
|
||||
//
|
||||
// return utils::ok<void>();
|
||||
// }
|
||||
|
||||
schema::const_iterator schema::begin() const {
|
||||
return const_iterator(root_->first_child_->next_sibling_);
|
||||
}
|
||||
|
|
@ -50,12 +77,23 @@ utils::result<std::shared_ptr<attribute_definition>, utils::error> schema::refer
|
|||
return utils::failure(result.err());
|
||||
}
|
||||
|
||||
utils::result<std::shared_ptr<schema_node>, utils::error> schema::attach_node(const std::shared_ptr<schema_node> &node,
|
||||
void schema::dump(std::ostream &os) const {
|
||||
for (const auto &node : *this) {
|
||||
os << "node [" << node.name() << "] (" << node.type_index().name() << ")\n";
|
||||
for (auto it = node.info().endpoint_begin(); it != node.info().endpoint_end(); ++it) {
|
||||
os << " " << node.name() << "::" << it->second->field_name() << " (" << it->second->type_name() << ") <---> " << it->second->foreign_endpoint()->node().name() << "::" << it->second->foreign_endpoint()->field_name() << " (" << it->second->foreign_endpoint()->type_name() << ")\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
utils::result<schema::node_ptr, utils::error> schema::attach_node(const std::shared_ptr<schema_node> &node,
|
||||
const std::string &parent) {
|
||||
if (has_node(node->type_index(), node->name())) {
|
||||
return utils::failure(make_error(error_code::NodeAlreadyExists, "Node '" + node->name() + "' already exists."));
|
||||
}
|
||||
|
||||
log_.info("attach node '%s' (type: %s)", node->name().c_str(), node->type_index().name());
|
||||
|
||||
// set node to root node
|
||||
auto parent_node = root_;
|
||||
if (!parent.empty()) {
|
||||
|
|
@ -75,7 +113,7 @@ utils::result<std::shared_ptr<schema_node>, utils::error> schema::attach_node(co
|
|||
return utils::ok(node);
|
||||
}
|
||||
|
||||
utils::result<std::shared_ptr<schema_node>, utils::error> schema::attach_node(const std::shared_ptr<schema_node> &node,
|
||||
utils::result<schema::node_ptr, utils::error> schema::attach_node(const std::shared_ptr<schema_node> &node,
|
||||
const std::type_index &type_index) {
|
||||
if (has_node(node->type_index(), node->name())) {
|
||||
return utils::failure(make_error(error_code::NodeAlreadyExists, "Node '" + node->name() + "' already exists."));
|
||||
|
|
@ -94,7 +132,7 @@ utils::result<std::shared_ptr<schema_node>, utils::error> schema::attach_node(co
|
|||
return utils::ok(node);
|
||||
}
|
||||
|
||||
utils::result<std::shared_ptr<schema_node>, utils::error> schema::find_node(const std::string &name) const {
|
||||
utils::result<schema::node_ptr, utils::error> schema::find_node(const std::string &name) const {
|
||||
// first search in the prototype map
|
||||
const auto i = nodes_by_name_.find(name);
|
||||
if (i == nodes_by_name_.end()) {
|
||||
|
|
@ -103,7 +141,7 @@ utils::result<std::shared_ptr<schema_node>, utils::error> schema::find_node(cons
|
|||
return utils::ok(i->second);
|
||||
}
|
||||
|
||||
utils::result<std::shared_ptr<schema_node>, utils::error> schema::find_node(const std::type_index &type_index) const {
|
||||
utils::result<schema::node_ptr, utils::error> schema::find_node(const std::type_index &type_index) const {
|
||||
const auto i = nodes_by_type_.find(type_index);
|
||||
if (i == nodes_by_type_.end()) {
|
||||
return utils::failure(make_error(error_code::NodeNotFound,
|
||||
|
|
@ -128,6 +166,33 @@ void schema::push_back_child(const node_ptr &parent, const node_ptr &child) {
|
|||
// child->depth = depth + 1;
|
||||
}
|
||||
|
||||
void schema::remove_node(const node_ptr &node) {
|
||||
auto next = node->next();
|
||||
|
||||
std::stack<node_ptr> nodes_to_remove;
|
||||
nodes_to_remove.push(node);
|
||||
|
||||
while (!nodes_to_remove.empty()) {
|
||||
const auto current = nodes_to_remove.top();
|
||||
|
||||
if (current->has_children()) {
|
||||
// Push all children to the stack (from right to left to maintain order)
|
||||
auto child = current->last_child_->previous_sibling_;
|
||||
while (child != current->first_child_) {
|
||||
nodes_to_remove.push(child);
|
||||
child = child->previous_sibling_;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
// No children left, safe to remove this node
|
||||
nodes_to_remove.pop();
|
||||
current->unlink();
|
||||
nodes_by_name_.erase(current->name());
|
||||
nodes_by_type_.erase(current->type_index());
|
||||
}
|
||||
}
|
||||
|
||||
bool schema::has_node(const std::string &name) const {
|
||||
return nodes_by_name_.count(name) > 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -44,6 +44,10 @@ const object::schema& schema_node::schema() const {
|
|||
return schema_;
|
||||
}
|
||||
|
||||
bool schema_node::has_children() const {
|
||||
return first_child_->next_sibling_ != last_child_;
|
||||
}
|
||||
|
||||
schema_node::node_ptr schema_node::next() const {
|
||||
// if we have a child, child is the next iterator to return
|
||||
// (if we don't do iterate over the siblings)
|
||||
|
|
@ -76,4 +80,11 @@ schema_node::node_ptr schema_node::prev() const {
|
|||
// is the parent of the node
|
||||
return parent_->parent_ ? parent_ : parent_->first_child_->next_sibling_;
|
||||
}
|
||||
|
||||
void schema_node::unlink() {
|
||||
previous_sibling_->next_sibling_ = next_sibling_;
|
||||
next_sibling_->previous_sibling_ = previous_sibling_;
|
||||
next_sibling_.reset();
|
||||
previous_sibling_.reset();
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue