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

Compare commits

base: sascha:3fb23e167ec763ce8dab1d7250225c928c951786
Branches Tags
sascha:main
sascha:feature/matador-ng
..
compare: sascha:96c6c78cb8e092eb52a815f59fec0a9c8517ea86
Branches Tags
sascha:feature/matador-ng
sascha:main

No commits in common. "3fb23e167ec763ce8dab1d7250225c928c951786" and "96c6c78cb8e092eb52a815f59fec0a9c8517ea86" have entirely different histories.
3fb23e167e ... 96c6c78cb8

4 changed files with 135 additions and 211 deletions
Show Stats Expand all files Collapse all files

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

@ -14,10 +14,6 @@
#include <typeindex> #include <typeindex>
#include <unordered_map> #include <unordered_map>
namespace matador::sql {
class connection;
}
namespace matador::query { namespace matador::query {
class schema_node final { class schema_node final {
public: public:
@ -77,9 +73,6 @@ public:
basic_schema(); basic_schema();
explicit basic_schema(const std::string &name); explicit basic_schema(const std::string &name);
[[nodiscard]] utils::result<void, utils::error> create(const sql::connection &conn) const;
[[nodiscard]] utils::result<void, utils::error> drop(const sql::connection &conn) const;
iterator begin(); iterator begin();
iterator end(); iterator end();
[[nodiscard]] const_iterator begin() const; [[nodiscard]] const_iterator begin() const;
@ -96,8 +89,8 @@ public:
[[nodiscard]] bool contains(const std::type_index &index) const; [[nodiscard]] bool contains(const std::type_index &index) const;
[[nodiscard]] const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>>& resolver_producers() const; const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_producer>>& resolver_producers() const;
[[nodiscard]] const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash>& collection_resolver_producers() const; const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash>& collection_resolver_producers() const;
protected: protected:
template<typename Type> template<typename Type>

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

@ -227,6 +227,9 @@ public:
return repo_.attach<Type, SuperType>(name, schema_observer<Type>{*this}, std::forward<Observers>(observers)...); return repo_.attach<Type, SuperType>(name, schema_observer<Type>{*this}, std::forward<Observers>(observers)...);
} }
[[nodiscard]] utils::result<void, utils::error> create(const sql::connection &conn) const;
[[nodiscard]] utils::result<void, utils::error> drop(const sql::connection &conn) const;
template<typename Type> template<typename Type>
[[nodiscard]] utils::result<void, utils::error> drop_table(const sql::connection &conn); [[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<void, utils::error> drop_table(const std::string &table_name, const sql::connection &conn);
@ -251,6 +254,9 @@ public:
void dump(std::ostream &os) const; void dump(std::ostream &os) const;
private: private:
[[nodiscard]] static sql::query_context build_add_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::dialect &d) ;
[[nodiscard]] static sql::query_context build_drop_constraint_context(const object::repository_node& node, const object::restriction& cons, const sql::dialect &d) ;
iterator insert_table(const std::type_index& ti, const object::repository_node &node, utils::generator_type generator_type); iterator insert_table(const std::type_index& ti, const object::repository_node &node, utils::generator_type generator_type);
private: private:

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

@ -1,27 +1,8 @@
#include "matador/query/basic_schema.hpp" #include "matador/query/basic_schema.hpp"
#include "matador/query/query.hpp" #include "matador/sql/executor.hpp"
#include "matador/sql/connection.hpp"
namespace matador::query { namespace matador::query {
namespace detail {
sql::query_context build_add_constraint_context(const object::repository_node &node,
const object::restriction &cons,
const sql::dialect &d);
sql::query_context build_drop_constraint_context(const object::repository_node &node,
const object::restriction &cons,
const sql::dialect &d);
utils::result<void, utils::error> create_tables(const object::repository &repo, const sql::connection &conn);
utils::result<void, utils::error> create_primary_key_constraints(const object::repository &repo, const sql::connection &conn);
utils::result<void, utils::error> create_foreign_key_constraints(const object::repository &repo, const sql::connection &conn);
utils::result<void, utils::error> drop_tables(const object::repository &repo, const sql::connection &conn);
utils::result<void, utils::error> drop_primary_key_constraints(const object::repository &repo, const sql::connection &conn);
utils::result<void, utils::error> drop_foreign_key_constraints(const object::repository &repo, const sql::connection &conn);
utils::result<void, utils::error> setup_primary_key_generator(const basic_schema &scm, const sql::connection &conn);
utils::result<void, utils::error> cleanup_primary_key_generator(const basic_schema &scm, const sql::connection &conn);
}
schema_node::schema_node(class table tab, std::unique_ptr<abstract_pk_generator> &&pk_generator, const object::repository_node& node) schema_node::schema_node(class table tab, std::unique_ptr<abstract_pk_generator> &&pk_generator, const object::repository_node& node)
: table_(std::move(tab)) : table_(std::move(tab))
, pk_generator_(std::move(pk_generator)) , pk_generator_(std::move(pk_generator))
@ -51,25 +32,6 @@ basic_schema::basic_schema(const std::string &name)
: repo_(name) { : repo_(name) {
} }
utils::result<void, utils::error> basic_schema::create(const sql::connection &conn) const {
std::vector<std::string> fk_sql_commands;
const auto q = query::create().schema(repo_.name()).compile(conn.dialect());
std::cout << q.sql << std::endl;
return detail::create_tables(repo_, conn)
.and_then([this, &conn]{ return detail::create_primary_key_constraints(repo_, conn);})
.and_then([this, &conn]{ return detail::create_foreign_key_constraints(repo_, conn);})
.and_then([this, &conn]{ return detail::setup_primary_key_generator(*this, conn);});
}
utils::result<void, utils::error> basic_schema::drop(const sql::connection &conn) const {
return detail::drop_primary_key_constraints(repo_, conn)
.and_then([this, &conn]{ return detail::drop_foreign_key_constraints(repo_, conn);})
.and_then([this, &conn]{ return detail::drop_tables(repo_, conn);})
.and_then([this, &conn]{ return detail::cleanup_primary_key_generator(*this, conn);});
}
basic_schema::iterator basic_schema::begin() { basic_schema::iterator basic_schema::begin() {
return schema_nodes_.begin(); return schema_nodes_.begin();
} }
@ -131,166 +93,4 @@ const std::unordered_map<std::type_index, std::unique_ptr<sql::object_resolver_p
const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash> & basic_schema::collection_resolver_producers() const { const std::unordered_map<object::collection_composite_key, std::unique_ptr<sql::collection_resolver_producer>, object::collection_composite_key_hash> & basic_schema::collection_resolver_producers() const {
return collection_resolver_producers_; return collection_resolver_producers_;
} }
namespace detail {
utils::result<void, utils::error> create_tables(const object::repository &repo, const sql::connection &conn) {
for (const auto &node: repo) {
auto ctx = query::create()
.table(node.name())
.columns(node.info().attributes())
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
return utils::ok<void>();
}
sql::query_context build_add_constraint_context(const object::repository_node &node,
const object::restriction &cons,
const sql::dialect &d) {
if (cons.is_foreign_key_constraint()) {
return alter()
.table(node.name())
.add_constraint(cons)
.compile(d);
}
if (cons.is_primary_key_constraint()) {
return alter()
.table(node.name())
.add_constraint(cons)
.compile(d);
}
return {};
}
sql::query_context build_drop_constraint_context(const object::repository_node &node,
const object::restriction &cons,
const sql::dialect &d) {
return alter()
.table(node.name())
.drop_constraint(cons)
.compile(d);
}
utils::result<void, utils::error> create_primary_key_constraints(const object::repository &repo, const sql::connection &conn) {
for (const auto &node: repo) {
for (const auto &cons: node.info().constraints()) {
if (!cons.is_primary_key_constraint()) {
continue;
}
auto ctx = build_add_constraint_context(node, cons, conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
}
return utils::ok<void>();
}
utils::result<void, utils::error> create_foreign_key_constraints(const object::repository &repo, const sql::connection &conn) {
for (const auto &node: repo) {
for (const auto &cons: node.info().constraints()) {
if (cons.is_primary_key_constraint()) {
continue;
}
auto ctx = build_add_constraint_context(node, cons, conn.dialect());
if (const auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
}
return utils::ok<void>();
}
utils::result<void, utils::error> drop_tables(const object::repository& repo, const sql::connection& conn) {
for (const auto &node: repo) {
auto ctx = query::drop()
.table(node.name())
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
return utils::ok<void>();
}
utils::result<void, utils::error> drop_primary_key_constraints(const object::repository& repo, const sql::connection& conn) {
for (const auto &node: repo) {
for (const auto &cons: node.info().constraints()) {
if (cons.is_primary_key_constraint()) {
continue;
}
auto ctx = alter()
.table(node.name())
.drop_constraint(cons)
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
}
return utils::ok<void>();
}
utils::result<void, utils::error> drop_foreign_key_constraints(const object::repository& repo, const sql::connection& conn) {
for (const auto &node: repo) {
for (const auto &cons: node.info().constraints()) {
if (!cons.is_primary_key_constraint()) {
continue;
}
auto ctx = alter()
.table(node.name())
.drop_constraint(cons)
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
}
return utils::ok<void>();
}
utils::result<void, utils::error> setup_primary_key_generator(const basic_schema &scm, const sql::connection& conn) {
for (const auto & [index, node]: scm) {
if (node.pk_generator().type() == utils::generator_type::Sequence) {
const auto result = create().sequence(node.name() + "_pk_seq").execute(conn);
if (!result) {
return utils::failure(result.err());
}
} else if (node.pk_generator().type() == utils::generator_type::Table) {
}
}
return utils::ok<void>();
}
utils::result<void, utils::error> cleanup_primary_key_generator(const basic_schema& scm, const sql::connection& conn) {
for (const auto & [index, node]: scm) {
if (node.pk_generator().type() == utils::generator_type::Sequence) {
const auto result = drop().sequence(node.name() + "_pk_seq").execute(conn);
if (!result) {
return utils::failure(result.err());
}
} else if (node.pk_generator().type() == utils::generator_type::Table) {
}
}
return utils::ok<void>();
}
}
} }

127
source/orm/query/schema.cpp
View File

@ -1,3 +1,5 @@
#include <utility>
#include "matador/query/schema.hpp" #include "matador/query/schema.hpp"
#include "matador/query/query.hpp" #include "matador/query/query.hpp"
@ -14,6 +16,102 @@
namespace matador::query { namespace matador::query {
utils::result<void, utils::error> schema::create(const sql::connection &conn) const {
std::vector<std::string> fk_sql_commands;
const auto q = query::create().schema(repo_.name()).compile(conn.dialect());
std::cout << q.sql << std::endl;
// create plain tables without constraints
for (const auto &node: repo_) {
auto ctx = query::create()
.table(node.name())
.columns(node.info().attributes())
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
// create primary key constraints
for (const auto &node: repo_) {
for (const auto &cons: node.info().constraints()) {
if (!cons.is_primary_key_constraint()) {
continue;
}
auto ctx = build_add_constraint_context(node, cons, conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
}
// create table constraints
for (const auto &node: repo_) {
for (const auto &cons: node.info().constraints()) {
if (cons.is_primary_key_constraint()) {
continue;
}
auto ctx = build_add_constraint_context(node, cons, conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
}
return utils::ok<void>();
}
utils::result<void, utils::error> schema::drop(const sql::connection &conn) const {
// drop table primary key constraints
for (const auto &node: repo_) {
for (const auto &cons: node.info().constraints()) {
if (cons.is_primary_key_constraint()) {
continue;
}
auto ctx = alter()
.table(node.name())
.drop_constraint(cons)
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
}
// drop table constraints
for (const auto &node: repo_) {
for (const auto &cons: node.info().constraints()) {
if (!cons.is_primary_key_constraint()) {
continue;
}
auto ctx = alter()
.table(node.name())
.drop_constraint(cons)
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
}
// drop table
for (const auto &node: repo_) {
auto ctx = query::drop()
.table(node.name())
.compile(conn.dialect());
if (auto result = conn.execute(ctx); !result) {
return utils::failure(result.err());
}
}
return utils::ok<void>();
}
utils::result<void, utils::error> schema::drop_table(const std::string &table_name, const sql::connection &conn) { utils::result<void, utils::error> schema::drop_table(const std::string &table_name, const sql::connection &conn) {
auto result = query::drop() auto result = query::drop()
.table(table_name) .table(table_name)
@ -38,6 +136,33 @@ void schema::dump(std::ostream &os) const {
repo_.dump(os); repo_.dump(os);
} }
sql::query_context schema::build_add_constraint_context(const object::repository_node &node,
const object::restriction &cons,
const sql::dialect &d) {
if (cons.is_foreign_key_constraint()) {
return alter()
.table(node.name())
.add_constraint(cons)
.compile(d);
}
if (cons.is_primary_key_constraint()) {
return alter()
.table(node.name())
.add_constraint(cons)
.compile(d);
}
return {};
}
sql::query_context schema::build_drop_constraint_context(const object::repository_node &node,
const object::restriction &cons,
const sql::dialect &d) {
return alter()
.table(node.name())
.drop_constraint(cons)
.compile(d);
}
schema::iterator schema::insert_table(const std::type_index &ti, const object::repository_node &node, const utils::generator_type generator_type) { schema::iterator schema::insert_table(const std::type_index &ti, const object::repository_node &node, const utils::generator_type generator_type) {
std::vector<table_column> columns; std::vector<table_column> columns;
for (const auto &attr: node.info().attributes()) { for (const auto &attr: node.info().attributes()) {
@ -49,7 +174,7 @@ schema::iterator schema::insert_table(const std::type_index &ti, const object::r
pk_generator = std::make_unique<identity_pk_generator>(); pk_generator = std::make_unique<identity_pk_generator>();
break; break;
case utils::generator_type::Sequence: case utils::generator_type::Sequence:
pk_generator = std::make_unique<sequence_pk_generator>(node.name() + "_pk_seq"); pk_generator = std::make_unique<sequence_pk_generator>(node.name());
break; break;
case utils::generator_type::Table: case utils::generator_type::Table:
pk_generator = std::make_unique<table_pk_generator>("TABLE_SEQS", node.name()); pk_generator = std::make_unique<table_pk_generator>("TABLE_SEQS", node.name());