508 lines
21 KiB
C++
508 lines
21 KiB
C++
#ifndef SCHEMA_HPP
|
|
#define SCHEMA_HPP
|
|
|
|
#include "matador/logger/log_manager.hpp"
|
|
|
|
#include "matador/object/join_columns_collector.hpp"
|
|
#include "matador/object/many_to_many_relation.hpp"
|
|
#include "matador/object/error_code.hpp"
|
|
#include "matador/object/schema_node.hpp"
|
|
#include "matador/object/schema_node_iterator.hpp"
|
|
|
|
#include "matador/utils/result.hpp"
|
|
#include "matador/utils/error.hpp"
|
|
|
|
#include "matador/logger/logger.hpp"
|
|
|
|
#include <memory>
|
|
#include <stack>
|
|
#include <string>
|
|
#include <unordered_set>
|
|
|
|
namespace matador::object {
|
|
utils::error make_error(error_code ec, const std::string &msg);
|
|
|
|
class schema;
|
|
|
|
/*
|
|
* 1. has_many (MM)
|
|
* no belongs to
|
|
* relation table is needed
|
|
* - element type is a foreign table (FT),
|
|
* then relation table must look like follows:
|
|
* relation_table<MM, FT>
|
|
* where MM and FT must be defined as belongs to
|
|
* - element type if a builtin type BT (i.e. string, int, etc.),
|
|
* then the relation table must look like follows:
|
|
* relation_table<MM, BT>
|
|
* where MM as belongs to and BT as given type
|
|
*
|
|
* 2. has_many_to_many (MM1, MM2)
|
|
* relation_table is needed
|
|
* relation_table<MM1, MM2>
|
|
* where MM1 and MM2 must be defined as belongs to
|
|
*
|
|
* 3. hans_many (MM) <-> belongs_to (BT)
|
|
* belongs_to has foreign key to the has_many side
|
|
* no relation table needed
|
|
*
|
|
* 4. has_one to belongs_to
|
|
* no relation table is needed
|
|
*
|
|
* 5. has_many (MM) <-> has_one (HO)
|
|
* invalid relation -> error
|
|
*
|
|
* 6. has_one
|
|
* no has_many or belongs_to
|
|
* invalid relation -> error
|
|
*/
|
|
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);
|
|
|
|
Type obj;
|
|
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<typename AttributeType>
|
|
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) {
|
|
}
|
|
|
|
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*/);
|
|
|
|
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);
|
|
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);
|
|
|
|
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);
|
|
template<class CollectionType>
|
|
void on_has_many_to_many(const char *id, CollectionType &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")) {
|
|
}
|
|
|
|
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);
|
|
|
|
template<typename ValueType>
|
|
void ensure_type_is_known();
|
|
|
|
private:
|
|
std::shared_ptr<schema_node> node_;
|
|
schema &schema_;
|
|
logger::logger log_;
|
|
join_columns_collector join_columns_collector_;
|
|
};
|
|
|
|
|
|
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 = "");
|
|
|
|
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 = schema_node::make_node<Type>(*this, name);
|
|
relation_completer<Type>::complete(node);
|
|
if (auto result = attach_node(node, parent); !result) {
|
|
return utils::failure(result.err());
|
|
}
|
|
|
|
return utils::ok<void>();
|
|
}
|
|
|
|
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 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.
|
|
*
|
|
* @return The first schema node iterator.
|
|
*/
|
|
[[nodiscard]] const_iterator begin() const;
|
|
|
|
/**
|
|
* Return the last schema node.
|
|
*
|
|
* @return The last schema node iterator.
|
|
*/
|
|
[[nodiscard]] const_iterator end() const;
|
|
|
|
/**
|
|
* Returns true if the schema contains
|
|
* no schema nodes.
|
|
*
|
|
* @return True if the schema is empty
|
|
*/
|
|
[[nodiscard]] bool empty() const;
|
|
|
|
/**
|
|
* Returns the current number of the schema node.
|
|
*
|
|
* @return Number of schema nodes
|
|
*/
|
|
[[nodiscard]] size_t size() const;
|
|
|
|
/**
|
|
* Returns the name of the schema.
|
|
*
|
|
* @return The name of the schema
|
|
*/
|
|
[[nodiscard]] std::string name() const;
|
|
|
|
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());
|
|
}
|
|
|
|
return utils::ok(result.value()->info<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());
|
|
}
|
|
|
|
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;
|
|
|
|
void dump(std::ostream &os) const;
|
|
|
|
private:
|
|
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<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>
|
|
[[nodiscard]] utils::result<node_ptr, utils::error> find_node() const {
|
|
return find_node(std::type_index(typeid(Type)));
|
|
}
|
|
|
|
[[nodiscard]] bool has_node(const std::string &name) const;
|
|
[[nodiscard]] bool has_node(const std::type_index &index) const;
|
|
[[nodiscard]] bool has_node(const node_ptr& node) const;
|
|
|
|
static void insert_node(const node_ptr &parent, const node_ptr &child);
|
|
void remove_node(const node_ptr &node);
|
|
|
|
private:
|
|
template<typename Type>
|
|
friend class relation_completer;
|
|
|
|
std::string name_;
|
|
std::shared_ptr<schema_node> root_;
|
|
|
|
t_node_map nodes_by_name_;
|
|
t_type_index_node_map nodes_by_type_;
|
|
logger::logger log_;
|
|
};
|
|
|
|
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*/) {
|
|
// Shortcut to value type of object_ptr::value_type in collection
|
|
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.
|
|
// Ensure value_type is known to the schema. Name will be added later
|
|
ensure_type_is_known<value_type>();
|
|
// Create and attach the relation node.
|
|
const std::type_index ti = typeid(many_to_many_relation<value_type, Type>);
|
|
if (const auto endpoint = node_->info().find_relation_endpoint(ti); 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);
|
|
}
|
|
} 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;
|
|
using relation_value_type = many_to_relation<Type, value_type>;
|
|
|
|
const auto node = schema_node::make_relation_node<relation_value_type>(
|
|
schema_, id, [join_column] {
|
|
return std::make_unique<relation_value_type>(join_column, "value");
|
|
});
|
|
|
|
const auto result = schema_.attach_node(node, "");
|
|
if (!result) {
|
|
// Todo: throw internal exception
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
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) {
|
|
const auto &foreign_node = result.value();
|
|
const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
|
|
node_->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type), local_endpoint);
|
|
const auto it = foreign_node->info_->find_relation_endpoint(node_->type_index());
|
|
if (it == foreign_node->info().endpoint_end()) {
|
|
// Todo: Throw error
|
|
return;
|
|
}
|
|
link_relation_endpoints(local_endpoint, it->second);
|
|
} else {
|
|
using relation_value_type = many_to_many_relation<typename CollectionType::value_type::value_type, Type>;
|
|
auto creator = [join_column, inverse_join_column] {
|
|
return std::make_unique<relation_value_type>(join_column, inverse_join_column);
|
|
};
|
|
|
|
auto node = schema_node::make_relation_node<relation_value_type>(schema_, id, std::move(creator));
|
|
|
|
auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, node_);
|
|
auto join_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, node);
|
|
auto inverse_join_endpoint = std::make_shared<relation_endpoint>(inverse_join_column, relation_type::BELONGS_TO,
|
|
node);
|
|
node_->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type), local_endpoint);
|
|
node->info_->register_relation_endpoint(node_->type_index(), join_endpoint);
|
|
link_relation_endpoints(local_endpoint, join_endpoint);
|
|
node->info_->register_relation_endpoint(typeid(typename CollectionType::value_type::value_type),
|
|
inverse_join_endpoint);
|
|
result = schema_.attach_node(node, "");
|
|
if (!result) {
|
|
// Todo: throw internal error
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename Type>
|
|
template<class CollectionType>
|
|
void relation_completer<Type>::on_has_many_to_many(const char *id,
|
|
CollectionType &collection,
|
|
const utils::foreign_attributes &attr) {
|
|
const auto join_columns = join_columns_collector_.collect<typename CollectionType::value_type::value_type>();
|
|
on_has_many_to_many(
|
|
id,
|
|
collection,
|
|
join_columns.inverse_join_column.c_str(),
|
|
join_columns.join_column.c_str(),
|
|
attr);
|
|
}
|
|
|
|
template<typename Type>
|
|
template<class ForeignPointerType>
|
|
void relation_completer<Type>::on_has_one(const char *id,
|
|
ForeignPointerType &/*obj*/,
|
|
const utils::foreign_attributes &/*attr*/) {
|
|
const auto ti = std::type_index(typeid(typename ForeignPointerType::value_type));
|
|
if (const auto result = schema_.find_node(ti); !result.is_ok()) {
|
|
// Node was not found
|
|
// Create node without the foreign relation endpoint
|
|
log_.debug("node '%s' has foreign key '%s' has one '%s'", node_->name().c_str(), id, ti.name());
|
|
node_->info_->
|
|
register_relation_endpoint(ti, std::make_shared<relation_endpoint>(id, relation_type::HAS_ONE, node_));
|
|
} else {
|
|
const auto &foreign_node = result.value();
|
|
if (const auto it = foreign_node->info().find_relation_endpoint(typeid(Type));
|
|
it != foreign_node->info().endpoint_end()) {
|
|
if (it->second->is_belongs_to()) {
|
|
it->second->node_ = foreign_node;
|
|
const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_ONE, node_);
|
|
node_->info_->register_relation_endpoint(ti, endpoint);
|
|
link_relation_endpoints(endpoint, it->second);
|
|
} else {
|
|
// Todo: Throw internal error
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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->is_has_one()) {
|
|
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);
|
|
} else 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 only endpoint.
|
|
const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, node_);
|
|
node_->info_->register_relation_endpoint(ti, endpoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
template<typename Type>
|
|
template<typename ValueType>
|
|
void relation_completer<Type>::ensure_type_is_known() {
|
|
if (auto result = schema_.find_node<ValueType>(); result) {
|
|
return;
|
|
}
|
|
auto result = schema_.attach_node(schema_node::make_node<Type>(schema_, ""), "");
|
|
relation_completer<ValueType>::complete(result.value());
|
|
}
|
|
}
|
|
|
|
#endif //SCHEMA_HPP
|