393 lines
15 KiB
C++
393 lines
15 KiB
C++
#ifndef MATADOR_SCHEMA_HPP
|
|
#define MATADOR_SCHEMA_HPP
|
|
|
|
#include "matador/object/observer.hpp"
|
|
|
|
#include "matador/sql/query_context.hpp"
|
|
#include "matador/sql/internal/object_resolver_producer.hpp"
|
|
#include "matador/sql/internal/collection_resolver_producer.hpp"
|
|
|
|
#include "matador/query/query_collection_resolver.hpp"
|
|
#include "matador/query/query_object_resolver.hpp"
|
|
#include "matador/query/select_query_builder.hpp"
|
|
#include "matador/query/basic_schema.hpp"
|
|
|
|
namespace matador::sql {
|
|
class connection_pool;
|
|
class connection;
|
|
class executor;
|
|
}
|
|
|
|
namespace matador::query {
|
|
template<typename Type>
|
|
class query_object_resolver_producer : public sql::object_resolver_producer {
|
|
public:
|
|
query_object_resolver_producer() = default;
|
|
query_object_resolver_producer(basic_schema& repo, const table& tab, std::string pk_name)
|
|
: object_resolver_producer(typeid(Type))
|
|
, repo_(repo)
|
|
, table_(tab)
|
|
, pk_name_(std::move(pk_name)) {}
|
|
|
|
std::shared_ptr<object::abstract_type_resolver> produce(sql::statement&& stmt) override {
|
|
return std::make_shared<query_object_resolver<Type>>(std::move(stmt));
|
|
}
|
|
|
|
utils::result<sql::query_context, utils::error> build_query(const sql::dialect& d) override;
|
|
|
|
private:
|
|
basic_schema& repo_;
|
|
const table& table_;
|
|
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, const std::string &join_column)
|
|
: joined_object_resolver_producer(root_type, typeid(Type), join_column)
|
|
, repo_(repo)
|
|
, table_(tab)
|
|
, pk_name_(std::move(pk_name)) {}
|
|
|
|
std::shared_ptr<object::abstract_type_resolver> produce(sql::statement&& stmt) override {
|
|
return std::make_shared<query_object_resolver<Type>>(std::move(stmt));
|
|
}
|
|
|
|
utils::result<sql::query_context, utils::error> build_query(const sql::dialect& /*d*/) override;
|
|
|
|
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:
|
|
query_collection_resolver_producer() = default;
|
|
query_collection_resolver_producer(const basic_schema& repo, const table& tab, std::string pk_name, const std::type_index& root_type, std::string join_column)
|
|
: collection_resolver_producer(root_type, typeid(Type), std::move(join_column))
|
|
, repo_(repo)
|
|
, table_(tab)
|
|
, pk_name_(std::move(pk_name))
|
|
{}
|
|
|
|
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()];
|
|
|
|
const auto stmt = select({*pk_column})
|
|
.from(table_)
|
|
.where(*join_column == utils::_)
|
|
.compile(d);
|
|
|
|
return utils::ok(stmt);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
private:
|
|
const basic_schema& repo_;
|
|
const table& table_;
|
|
std::string pk_name_;
|
|
};
|
|
|
|
template<typename Type>
|
|
class query_collection_primitive_resolver_producer : public sql::collection_resolver_producer {
|
|
public:
|
|
query_collection_primitive_resolver_producer() = default;
|
|
query_collection_primitive_resolver_producer(const basic_schema& repo, const table& tab, std::string value_name, const std::type_index& root_type, std::string join_column)
|
|
: collection_resolver_producer(root_type, typeid(Type), std::move(join_column))
|
|
, repo_(repo)
|
|
, table_(tab)
|
|
, value_name_(std::move(value_name))
|
|
{}
|
|
|
|
utils::result<sql::query_context, utils::error> build_query(const sql::dialect& d) override {
|
|
const auto *value_column = table_[value_name_];
|
|
const auto *join_column = table_[collection_name()];
|
|
|
|
const auto stmt = select({*value_column})
|
|
.from(table_)
|
|
.where(*join_column == utils::_)
|
|
.compile(d);
|
|
|
|
return utils::ok(stmt);
|
|
}
|
|
|
|
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*/);
|
|
}
|
|
|
|
private:
|
|
const basic_schema& repo_;
|
|
const table& table_;
|
|
std::string value_name_;
|
|
};
|
|
|
|
class producer_creator final {
|
|
public:
|
|
producer_creator(basic_schema& schema, const std::type_index& root_type)
|
|
: schema_(schema)
|
|
, root_type_(root_type)
|
|
{}
|
|
|
|
template<typename BaseType>
|
|
static void on_base(const BaseType&) {}
|
|
template<typename ValueType>
|
|
static void on_primary_key(const char * /*id*/, ValueType &/*value*/, const utils::primary_key_attribute& /*attr*/) {}
|
|
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
|
|
template<class Type>
|
|
static void on_attribute(const char * /*id*/, Type &/*value*/, const utils::field_attributes &/*attr*/) {}
|
|
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 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"};
|
|
}
|
|
if (!it->second.node().info().has_primary_key()) {
|
|
throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"};
|
|
}
|
|
|
|
auto producer = std::make_unique<query_joined_object_resolver_producer<typename Pointer::value_type>>(
|
|
schema_,
|
|
it->second.table(),
|
|
it->second.node().info().primary_key_attribute()->name(),
|
|
root_type_,
|
|
join_column);
|
|
const object::collection_composite_key key{root_type_, typeid(Pointer), join_column};
|
|
schema_.joined_object_resolver_producers_[key] = std::move(producer);
|
|
}
|
|
|
|
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) {
|
|
const auto it = schema_.find(typeid(typename CollectionType::value_type::value_type));
|
|
if (it == schema_.end()) {
|
|
throw query_builder_exception{error_code::UnknownType, "Unknown type"};
|
|
}
|
|
if (!it->second.node().info().has_primary_key()) {
|
|
throw query_builder_exception{error_code::MissingPrimaryKey, "Missing primary key"};
|
|
}
|
|
|
|
auto producer = std::make_unique<query_collection_resolver_producer<typename CollectionType::value_type>>(
|
|
schema_,
|
|
it->second.table(),
|
|
it->second.node().info().primary_key_attribute()->name(),
|
|
root_type_,
|
|
join_column);
|
|
const object::collection_composite_key key{root_type_, typeid(typename CollectionType::value_type), join_column};
|
|
schema_.collection_resolver_producers_[key] = std::move(producer);
|
|
}
|
|
|
|
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) {
|
|
const auto it = schema_.find(id);
|
|
if (it == schema_.end()) {
|
|
throw query_builder_exception{error_code::UnknownType, "Unknown type" + std::string{id}};
|
|
}
|
|
auto producer = std::make_unique<query_collection_primitive_resolver_producer<typename CollectionType::value_type>>(
|
|
schema_,
|
|
it->second.table(),
|
|
"value",
|
|
root_type_,
|
|
join_column);
|
|
const object::collection_composite_key key{root_type_, typeid(typename CollectionType::value_type), join_column};
|
|
schema_.collection_resolver_producers_[key] = std::move(producer);
|
|
}
|
|
|
|
template<class CollectionType>
|
|
void on_has_many_to_many(const char *id, CollectionType &, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &/*attr*/) {
|
|
const auto it = schema_.find(id);
|
|
if (it == schema_.end()) {
|
|
throw query_builder_exception{error_code::UnknownType, "Unknown type"};
|
|
}
|
|
|
|
auto producer = std::make_unique<query_collection_resolver_producer<typename CollectionType::value_type>>(
|
|
schema_,
|
|
it->second.table(),
|
|
inverse_join_column,
|
|
root_type_,
|
|
join_column);
|
|
const object::collection_composite_key key{root_type_, typeid(typename CollectionType::value_type), inverse_join_column};
|
|
schema_.collection_resolver_producers_[key] = std::move(producer);
|
|
}
|
|
|
|
template<class CollectionType>
|
|
void on_has_many_to_many(const char *id, CollectionType &, const utils::foreign_attributes &/*attr*/) {
|
|
const auto it = schema_.find(id);
|
|
if (it == schema_.end()) {
|
|
throw query_builder_exception{error_code::UnknownType, "Unknown type"};
|
|
}
|
|
|
|
object::join_columns_collector collector;
|
|
const auto jc = collector.collect<typename CollectionType::value_type::value_type>();
|
|
|
|
auto producer = std::make_unique<query_collection_resolver_producer<typename CollectionType::value_type>>(
|
|
schema_,
|
|
it->second.table(),
|
|
jc.join_column,
|
|
root_type_,
|
|
jc.inverse_join_column);
|
|
const object::collection_composite_key key{root_type_, typeid(typename CollectionType::value_type), jc.join_column};
|
|
schema_.collection_resolver_producers_[key] = std::move(producer);
|
|
|
|
}
|
|
|
|
private:
|
|
basic_schema& schema_;
|
|
const std::type_index root_type_;
|
|
};
|
|
|
|
class schema;
|
|
|
|
using schema_ref = std::reference_wrapper<schema>;
|
|
|
|
template<typename Type>
|
|
class schema_observer final : public object::observer<Type> {
|
|
public:
|
|
explicit schema_observer(schema& s)
|
|
: schema_(s) {}
|
|
template<typename OtherType>
|
|
explicit schema_observer(const schema_observer<OtherType> &x)
|
|
: schema_(x.schema_)
|
|
{}
|
|
void on_attach(const object::repository_node &node, const Type &prototype) const override;
|
|
void on_detach(const object::repository_node &node, const Type &prototype) const override;
|
|
void on_insert(const Type &obj) override;
|
|
void on_update(const Type &obj) override;
|
|
void on_delete(const Type &obj) override;
|
|
|
|
private:
|
|
template < class OtherType >
|
|
friend class schema_observer;
|
|
|
|
schema& schema_;
|
|
};
|
|
|
|
class schema final : public basic_schema {
|
|
public:
|
|
using basic_schema::basic_schema;
|
|
using basic_schema::iterator;
|
|
using basic_schema::const_iterator;
|
|
using basic_schema::contains;
|
|
using basic_schema::find;
|
|
|
|
|
|
template<typename Type, typename... Observers>
|
|
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, Observers&&... observers) {
|
|
return repo_.attach<Type>(name, schema_observer<Type>{*this}, std::forward<Observers>(observers)...);
|
|
}
|
|
|
|
template<typename Type, typename... Observers>
|
|
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, const std::string &parent, Observers&&... observers) {
|
|
return repo_.attach<Type>(name, parent, schema_observer<Type>{*this}, std::forward<Observers>(observers)...);
|
|
}
|
|
|
|
template<typename Type, typename SuperType, typename... Observers>
|
|
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, Observers&&... observers) {
|
|
return repo_.attach<Type, SuperType>(name, schema_observer<Type>{*this}, std::forward<Observers>(observers)...);
|
|
}
|
|
|
|
template<typename Type>
|
|
[[nodiscard]] utils::result<void, utils::error> drop_table(const sql::connection &conn);
|
|
[[nodiscard]] static utils::result<void, utils::error> drop_table(const std::string &table_name, const sql::connection &conn);
|
|
|
|
[[nodiscard]] static utils::result<std::vector<object::attribute>, utils::error> describe_table(const std::string &table_name, const sql::connection &conn) ;
|
|
[[nodiscard]] utils::result<bool, utils::error> table_exists(const std::string &table_name, const sql::connection &conn) const;
|
|
|
|
template<typename Type>
|
|
iterator find() { return basic_schema::find(typeid(Type)); }
|
|
|
|
template<typename Type>
|
|
[[nodiscard]] const_iterator find() const { return basic_schema::find(typeid(Type)); }
|
|
|
|
template < typename Type >
|
|
[[nodiscard]] bool contains() const {
|
|
return basic_schema::contains(std::type_index(typeid(Type)));
|
|
}
|
|
|
|
void dump(std::ostream &os) const;
|
|
|
|
private:
|
|
iterator insert_table(const std::type_index& ti, const object::repository_node &node, utils::generator_type generator_type);
|
|
|
|
private:
|
|
template<typename Type>
|
|
friend class schema_observer;
|
|
};
|
|
|
|
template<typename Type>
|
|
utils::result<void, utils::error> schema::drop_table(const sql::connection &conn) {
|
|
auto info = repo_.basic_info<Type>();
|
|
if (info) {
|
|
return drop_table(info->get().name(), conn);
|
|
}
|
|
|
|
return utils::failure(info.err());
|
|
}
|
|
|
|
template<typename Type>
|
|
utils::result<sql::query_context, utils::error> query_object_resolver_producer<Type>::build_query(const sql::dialect &d) {
|
|
producer_creator pc(repo_, typeid(Type));
|
|
Type obj;
|
|
access::process(pc, obj);
|
|
|
|
select_query_builder qb(repo_);
|
|
const auto *pk_column = table_[pk_name_];
|
|
const auto result = qb.build<Type>(*pk_column == utils::_);
|
|
if (!result) {
|
|
return utils::failure(result.err());
|
|
}
|
|
|
|
return utils::ok(result->compile(d));
|
|
}
|
|
|
|
template<typename Type>
|
|
utils::result<sql::query_context, utils::error> query_joined_object_resolver_producer<Type>::build_query(const sql::dialect &d) {
|
|
// producer_creator pc(repo_, typeid(Type));
|
|
// Type obj;
|
|
// access::process(pc, obj);
|
|
|
|
select_query_builder qb(repo_);
|
|
const auto *join_column = table_[collection_name()];
|
|
const auto result = qb.build<Type>(*join_column == utils::_);
|
|
if (!result) {
|
|
return utils::failure(result.err());
|
|
}
|
|
|
|
return utils::ok(result->compile(d));
|
|
}
|
|
|
|
template <typename Type>
|
|
void schema_observer<Type>::on_attach(const object::repository_node &node, const Type &/*prototype*/) const {
|
|
primary_key_generator_finder finder;
|
|
const auto generator_type = finder.find(node.info<Type>().get());
|
|
|
|
const auto it = schema_.insert_table(typeid(Type), node, generator_type);
|
|
|
|
if (!it->second.node().info().has_primary_key()) {
|
|
return;
|
|
}
|
|
|
|
auto producer = std::make_unique<query_object_resolver_producer<Type>>(schema_, it->second.table(), it->second.node().info().primary_key_attribute()->name());
|
|
schema_.resolver_producers_[typeid(Type)] = std::move(producer);
|
|
}
|
|
|
|
template <typename Type>
|
|
void schema_observer<Type>::on_detach(const object::repository_node &/*node*/, const Type &/*prototype*/) const {}
|
|
template <typename Type>
|
|
void schema_observer<Type>::on_insert(const Type &/*obj*/) {}
|
|
template <typename Type>
|
|
void schema_observer<Type>::on_update(const Type &/*obj*/) {}
|
|
template <typename Type>
|
|
void schema_observer<Type>::on_delete(const Type &/*obj*/) {}
|
|
} // namespace matador::query
|
|
#endif //MATADOR_SCHEMA_HPP
|