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

creating tables progress

This commit is contained in:
Sascha Kühl 2025-07-16 16:15:31 +02:00
parent a0bfa3261b
commit 581b93c5ea
7 changed files with 266 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
demo/sandbox.cpp
View File

@ -98,6 +98,30 @@ struct user {
field::has_one(op, "profile_id", profile, matador::utils::default_foreign_attributes );
}
};
struct person {
unsigned int id{};
std::string name;
template<typename Operator>
void process(Operator &op) {
namespace field = matador::access;
field::primary_key( op, "id", id );
field::attribute( op, "name", name, 255 );
}
};
struct person_repo {
unsigned int id{};
matador::object::collection<matador::object::object_ptr<person>> person_list;
template<typename Operator>
void process(Operator &op) {
namespace field = matador::access;
field::primary_key( op, "id", id );
field::has_many( op, "person_list", person_list, "person_id", matador::utils::default_foreign_attributes );
}
};
}
using namespace demo;
@ -107,66 +131,84 @@ int main() {
// logger::default_min_log_level(logger::log_level::LVL_DEBUG);
// logger::add_log_sink(logger::create_stdout_sink());
// {
// // has_many with builtin-type
// object::schema schema;
//
// auto result = schema.attach<names>("names");
//
// schema.dump(std::cout);
// }
{
// has_many with builtin-type
// has_many with foreign without belongs_to
object::schema schema;
auto result = schema.attach<names>("names");
auto result = schema.attach<person_repo>("person_repo")
.and_then([&schema] { return schema.attach<person>("persons"); });
schema.dump(std::cout);
}
{
// has_many to belongs_to
// has_many with foreign without belongs_to
object::schema schema;
auto result = schema.attach<author>("authors")
.and_then([&schema] { return schema.attach<book>("books"); });
schema.dump(std::cout);
}
{
// belongs_to to has_many
object::schema schema;
auto result = schema.attach<book>("books")
.and_then([&schema] { return schema.attach<author>("authors"); });
schema.dump(std::cout);
}
{
// has_many_to_many (with join columns first)
object::schema schema;
auto result = schema.attach<demo::ingredient>("ingredients")
.and_then([&schema] { return schema.attach<recipe>("recipes"); });
schema.dump(std::cout);
}
{
// has_many_to_many (with join columns last)
object::schema schema;
auto result = schema.attach<demo::recipe>("recipes")
.and_then([&schema] { return schema.attach<ingredient>("ingredients"); });
schema.dump(std::cout);
}
{
// belongs_to to has_one
object::schema schema;
auto result = schema.attach<profile>("profiles")
.and_then([&schema] { return schema.attach<user>("users"); });
schema.dump(std::cout);
}
{
// has_one to belongs_to
object::schema schema;
auto result = schema.attach<user>("users")
.and_then([&schema] { return schema.attach<profile>("profiles"); });
auto result = schema.attach<person>("persons")
.and_then([&schema] { return schema.attach<person_repo>("person_repo"); });
schema.dump(std::cout);
}
// {
// // has_many to belongs_to
// object::schema schema;
//
// auto result = schema.attach<author>("authors")
// .and_then([&schema] { return schema.attach<book>("books"); });
//
// schema.dump(std::cout);
// }
// {
// // belongs_to to has_many
// object::schema schema;
//
// auto result = schema.attach<book>("books")
// .and_then([&schema] { return schema.attach<author>("authors"); });
//
// schema.dump(std::cout);
// }
// {
// // has_many_to_many (with join columns first)
// object::schema schema;
//
// auto result = schema.attach<demo::ingredient>("ingredients")
// .and_then([&schema] { return schema.attach<recipe>("recipes"); });
//
// schema.dump(std::cout);
// }
// {
// // has_many_to_many (with join columns last)
// object::schema schema;
//
// auto result = schema.attach<demo::recipe>("recipes")
// .and_then([&schema] { return schema.attach<ingredient>("ingredients"); });
//
// schema.dump(std::cout);
// }
// {
// // belongs_to to has_one
// object::schema schema;
//
// auto result = schema.attach<profile>("profiles")
// .and_then([&schema] { return schema.attach<user>("users"); });
//
// schema.dump(std::cout);
// }
// {
// // has_one to belongs_to
// object::schema schema;
//
// auto result = schema.attach<user>("users")
// .and_then([&schema] { return schema.attach<profile>("profiles"); });
//
// schema.dump(std::cout);
// }
}

8
demo/work.cpp
View File

@ -70,13 +70,13 @@ using namespace work::models;
// payload.is_polymorphic_type<jobs::IdPayload>();
int main() {
logger::default_min_log_level(logger::log_level::LVL_DEBUG);
logger::add_log_sink(logger::create_stdout_sink());
// logger::default_min_log_level(logger::log_level::LVL_DEBUG);
// logger::add_log_sink(logger::create_stdout_sink());
const object::schema schema("Administration");
sql::connection_pool<sql::connection> pool("postgres://news:news@127.0.0.1:15432/matador", 4);
// sql::connection_pool<sql::connection> pool("postgres://test:test123!@127.0.0.1:5432/matador", 4);
// sql::connection_pool<sql::connection> pool("postgres://news:news@127.0.0.1:15432/matador", 4);
sql::connection_pool<sql::connection> pool("postgres://test:test123!@127.0.0.1:5432/matador", 4);
orm::session ses(pool);

2
demo/work/admin/CollectionCenter.hpp
View File

@ -39,7 +39,7 @@ struct CollectionCenter : core::Model {
field::attribute( op, "name", name, 511 );
field::attribute( op, "symbol", symbol );
field::attribute( op, "type", type );
field::has_many( op, "collection_center_users", users, "collection_center_id", matador::utils::fetch_type::LAZY );
field::has_many( op, "collection_center_users", users, "users_id", matador::utils::fetch_type::LAZY );
}
};

154
include/matador/object/relation_completer.hpp
View File

@ -9,10 +9,55 @@
#include "matador/logger/log_manager.hpp"
#include <iostream>
#include <stack>
#include <utility>
namespace matador::object {
class join_column_finder final {
public:
template<typename Type>
static bool has_join_column(const std::string &join_column) {
join_column_finder finder(join_column);
Type obj;
finder.found_ = false;
access::process(finder, obj);
return finder.found_;
}
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*/) {
found_ = requested_join_column_ == id;
}
template<class ForeignPointerType>
static void on_has_one(const char * /*id*/, ForeignPointerType &/*obj*/, const utils::foreign_attributes &/*attr*/) {}
template<class CollectionType>
static void on_has_many(const char *id, CollectionType &, const char *join_column, const utils::foreign_attributes &attr) {}
template<class CollectionType>
static 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>
static void on_has_many_to_many(const char * /*id*/, CollectionType & /*collection*/, const utils::foreign_attributes &/*attr*/) {}
private:
explicit join_column_finder(std::string join_column)
: requested_join_column_(std::move(join_column)) {}
private:
std::string requested_join_column_;
bool found_ = false;
};
/*
* 1. has_many (MM)
* no belongs to
@ -110,6 +155,18 @@ private:
join_columns_collector join_columns_collector_{};
};
inline void dump(std::ostream &os, const std::shared_ptr<schema_node> &node) {
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() << ")";
if (it->second->foreign_endpoint()) {
os << " <---> " << it->second->node().name() << "::" << it->second->foreign_endpoint()->field_name() << " (" << it->second->foreign_endpoint()->type_name() << ")\n";
} else {
os << " -> " << it->second->node().type_index().name() << "\n";
}
}
}
template<typename Type>
template<class CollectionType>
void relation_completer<Type>::on_has_many(const char *id, CollectionType &,
@ -118,7 +175,7 @@ void relation_completer<Type>::on_has_many(const char *id, CollectionType &,
std::enable_if_t<is_object_ptr<typename CollectionType::value_type>::value> * /*unused*/) {
// Shortcut to a value type of object_ptr::value_type in a collection
using value_type = typename CollectionType::value_type::value_type;
using relation_value_type = many_to_many_relation<value_type, Type>;
using relation_value_type = many_to_many_relation<Type, value_type>;
// Check if the object_ptr type is already inserted in the schema (by id)
auto result = schema_.find_node(typeid(value_type));
@ -126,17 +183,79 @@ void relation_completer<Type>::on_has_many(const char *id, CollectionType &,
// Todo: throw internal error or attach node
return;
}
auto local_it = nodes_.top()->info().find_relation_endpoint(typeid(value_type));
if (local_it == nodes_.top()->info().endpoint_end()) {
const auto foreign_node = result.value();
// has foreign node corresponding join column (join_column)
if (const auto it = foreign_node->info_->find_relation_endpoint(typeid(Type)); it != foreign_node->info().endpoint_end()) {
// corresponding belongs_to is available and was called (has_many <-> belongs_to)
// complete the relation
const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, foreign_node);
nodes_.top()->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
link_relation_endpoints(local_endpoint, it->second);
} else if (join_column_finder::has_join_column<value_type>(join_column)) {
// corresponding belongs_to is available but was not called (has_many <-> belongs_to)
// prepare the relation
const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, foreign_node);
nodes_.top()->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
} else {
// A relation table is necessary
// } else if (const auto endpoint = nodes_.top()->info().find_relation_endpoint(typeid(relation_value_type)); endpoint == nodes_.top()->info().endpoint_end()) {
// Endpoint was not found.
// Always attach a many-to-many relation type. If later a
// belongs-to relation handles this relation, the many-to-many
// relation is maybe detached.
log_.debug("node '%s' has has many foreign keys '%s' mapped by '%s'", nodes_.top()->name().c_str(), id, join_column);
result = schema_node::make_relation_node<relation_value_type>(
schema_.schema(), id, [join_column] {
return std::make_unique<relation_value_type>("id", join_column);
});
if (!result) {
// Todo: throw internal error
return;
}
const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, result.value());
local_it = nodes_.top()->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
}
auto foreign_it = result.value()->info().find_relation_endpoint(typeid(value_type));
if (foreign_it == result.value()->info().endpoint_end()) {
const auto foreign_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, nodes_.top());
foreign_it = result.value()->info_->register_relation_endpoint(typeid(Type), foreign_endpoint);
}
link_relation_endpoints(local_it->second, foreign_it->second);
const auto foreign_endpoint = std::make_shared<relation_endpoint>("id", relation_type::BELONGS_TO, nodes_.top());
nodes_.top()->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
result.value()->info_->register_relation_endpoint(nodes_.top()->type_index(), foreign_endpoint);
link_relation_endpoints(local_endpoint, foreign_endpoint);
const auto foreign_value_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, foreign_node);
result.value()->info_->register_relation_endpoint(typeid(value_type), foreign_value_endpoint);
// dump( std::cout, nodes_.top() );
// dump( std::cout, result.value() );
// if (const auto detach_result = schema_.detach_node(foreign_node); !detach_result) {
// // Todo: throw internal error
// return;
// }
}
// } else {
// if (const auto rit = foreign_node->info_->find_relation_endpoint(nodes_.top()->type_index());
// rit != foreign_node->info().endpoint_end()) {
// if (rit->second->is_belongs_to()) {
// rit->second->node_ = foreign_node;
// const auto localEndpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, nodes_.top());
// nodes_.top()->info_->register_relation_endpoint(nodes_.top()->type_index(), localEndpoint);
// link_relation_endpoints(localEndpoint, rit->second);
// } else {
// // Todo: throw internal error relation node has invalid type
// }
// } else {
// // Todo: throw internal error couldn't find relation node
// }
// }
// auto local_it = nodes_.top()->info().find_relation_endpoint(typeid(value_type));
// if (local_it == nodes_.top()->info().endpoint_end()) {
// const auto local_endpoint = std::make_shared<relation_endpoint>(id, relation_type::HAS_MANY, result.value());
// local_it = nodes_.top()->info_->register_relation_endpoint(typeid(value_type), local_endpoint);
// }
// auto foreign_it = result.value()->info().find_relation_endpoint(typeid(value_type));
// if (foreign_it == result.value()->info().endpoint_end()) {
// const auto foreign_endpoint = std::make_shared<relation_endpoint>(join_column, relation_type::BELONGS_TO, nodes_.top());
// foreign_it = result.value()->info_->register_relation_endpoint(typeid(Type), foreign_endpoint);
// }
// link_relation_endpoints(local_it->second, foreign_it->second);
/*
if (const auto endpoint = nodes_.top()->info().find_relation_endpoint(typeid(relation_value_type)); endpoint == nodes_.top()->info().endpoint_end()) {
@ -308,13 +427,16 @@ void relation_completer<Type>::on_belongs_to(const char *id,
// 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(nodes_.top()->type_index());
it != foreign_node->info().endpoint_end()) {
if (const auto it = foreign_node->info_->find_relation_endpoint(nodes_.top()->type_index()); 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, foreign_node);
nodes_.top()->info_->register_relation_endpoint(ti, endpoint);
link_relation_endpoints(endpoint, it->second);
const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, foreign_node);
nodes_.top()->info_->register_relation_endpoint(ti, endpoint);
link_relation_endpoints(endpoint, it->second);
} else if (it->second->is_has_many()) {
const auto endpoint = std::make_shared<relation_endpoint>(id, relation_type::BELONGS_TO, foreign_node);
nodes_.top()->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

2
include/matador/object/schema.hpp
View File

@ -39,6 +39,7 @@ public:
template<typename Type>
[[nodiscard]] utils::result<void, utils::error> attach(const std::string &name, const std::string &parent = "") {
if (const auto it = nodes_by_type_.find(typeid(Type)); it == nodes_by_type_.end() ) {
// if the type was not found
auto node = schema_node::make_node<Type>(*this, name);
if (auto result = attach_node(node, parent); !result) {
return utils::failure(result.err());
@ -148,6 +149,7 @@ public:
const std::type_index &type_index) const;
void dump(std::ostream &os) const;
static void dump(std::ostream &os, const node_ptr& node);
private:
using t_node_map = std::unordered_map<std::string, node_ptr>;

23
source/core/object/schema.cpp
View File

@ -64,16 +64,21 @@ utils::result<std::shared_ptr<attribute_definition>, utils::error> schema::refer
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() << ")";
if (it->second->foreign_endpoint()) {
os << " <---> " << it->second->node().name() << "::" << it->second->foreign_endpoint()->field_name() << " (" << it->second->foreign_endpoint()->type_name() << ")\n";
} else {
os << "\n";
}
}
dump(os, node);
}
os << "\n";
}
void schema::dump( std::ostream& os, const node_ptr& node ) {
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() << ")";
if (it->second->foreign_endpoint()) {
os << " <---> " << it->second->node().name() << "::" << it->second->foreign_endpoint()->field_name() << " (" << it->second->foreign_endpoint()->type_name() << ")\n";
} else {
os << " -> " << it->second->node().name() << " (type: " << it->second->node().type_index().name() << ")\n";
}
}
}
utils::result<schema::node_ptr, utils::error> schema::attach_node(const std::shared_ptr<schema_node> &node,

35
source/orm/orm/session.cpp
View File

@ -25,13 +25,12 @@ utils::result<void, utils::error> session::create_schema() const {
for (const auto &node: *schema_) {
for (auto it = node->info().endpoint_begin(); it != node->info().endpoint_end(); ++it) {
std::cout << "Dependency graph " << node->name() << " (" << node.get() << ")" << " -> " << it->second->node_ptr()->name() << " (" << it->second->node_ptr().get() << ")" << std::endl;
dependency_graph[node->name()].push_back(it->second->node().name());
auto n = it->second->node_ptr();
auto nn = node->name();
if (it->second->is_has_one()) {
continue;
}
// if (it->second->is_has_many()) {
// continue;
// }
if (const auto dit = in_degree.find(it->second->node().name()); dit == in_degree.end()) {
in_degree[it->second->node().name()] = std::make_pair(1, it->second->node_ptr());
} else {
@ -62,9 +61,9 @@ utils::result<void, utils::error> session::create_schema() const {
}
}
for (const auto &it : in_degree) {
std::cout << "In degree table " << it.second.second->name() << " (" << it.second.first << ")" << std::endl;
}
for (const auto &it : in_degree) {
std::cout << "In degree table " << it.second.second->name() << " (" << it.second.first << ")" << std::endl;
}
while (!zero_in_degree.empty()) {
@ -84,25 +83,21 @@ utils::result<void, utils::error> session::create_schema() const {
// Step 3: Check for cycles
if (sorted_order.size() != in_degree.size()) {
std::cout << "Cycle detected in table dependencies (sorted order size: " << sorted_order.size() << ", in degree size: " << in_degree.size() << ")" << std::endl;
// throw std::logic_error("Cycle detected in table dependencies");
}
// Step 4: Create tables in the sorted order
auto c = pool_.acquire();
for (const auto &node : sorted_order) {
std::cout << "Creating table " << node->name() << std::endl;
// schema_.
// auto result = query::query::create()
//
// .table(table_name, /* Pass table definition here */)
//
// .execute(*c);
//
// if (!result) {
//
// return utils::failure(result.err());
//
// }
// auto result = query::query::create()
// .table(node->name(), node->info().definition().columns())
// .execute(*c);
// if (!result) {
// return utils::failure(result.err());
// }
}
// auto c = pool_.acquire();