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

added more pk generator types

This commit is contained in:
Sascha Kühl 2026-02-26 07:31:35 +01:00
parent 0157233b02
commit 626eae1ac8
17 changed files with 132 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
backends/postgres/test/CMakeLists.txt
View File

@ -2,8 +2,8 @@ CPMAddPackage("gh:catchorg/Catch2@3.7.1")
list(APPEND CMAKE_MODULE_PATH ${catch2_SOURCE_DIR}/extras)
set(POSTGRES_CONNECTION_STRING "postgres://test:test123!@127.0.0.1:15442/matador")
#set(POSTGRES_CONNECTION_STRING "postgres://test:test123!@127.0.0.1:5432/matador")
#set(POSTGRES_CONNECTION_STRING "postgres://test:test123!@127.0.0.1:15442/matador")
set(POSTGRES_CONNECTION_STRING "postgres://test:test123!@127.0.0.1:5432/matador")
configure_file(Connection.hpp.in ${PROJECT_BINARY_DIR}/backends/postgres/test/connection.hpp @ONLY IMMEDIATE)

2
include/matador/orm/session.hpp
View File

@ -112,7 +112,7 @@ utils::result<object::object_ptr<Type>, utils::error> session::insert(object::ob
// Execute all steps; for Identity steps read RETURNING and write pk back into the object
for (auto &step : *steps) {
if (step.pk_is_unset && step.set_pk) {
if (step.pk_generator == utils::generator_type::Manually) {
if (step.pk_generator == utils::generator_type::Manual) {
if (step.pk_is_unset()) {
return utils::failure(make_error(error_code::NoPrimaryKey, "Manual primary key is required but unset."));
}

9
include/matador/query/abstract_pk_generator.hpp
View File

@ -3,6 +3,7 @@
#include "matador/utils/error.hpp"
#include "matador/utils/result.hpp"
#include "matador/utils/primary_key_generator_type.hpp"
#include <cstdint>
@ -14,6 +15,14 @@ class abstract_pk_generator {
public:
virtual ~abstract_pk_generator() = default;
virtual utils::result<int64_t, utils::error> next_id(const sql::executor& exec) = 0;
[[nodiscard]] utils::generator_type type() const;
protected:
explicit abstract_pk_generator(utils::generator_type type);
private:
utils::generator_type generator_type_{};
};
}
#endif //MATADOR_ABSTRACT_PK_GENERATOR_HPP

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

@ -1,31 +1,33 @@
#ifndef MATADOR_BASIC_SCHEMA_HPP
#define MATADOR_BASIC_SCHEMA_HPP
#include <memory>
#include <typeindex>
#include <unordered_map>
#include "matador/object/repository.hpp"
#include "matador/query/abstract_pk_generator.hpp"
#include "matador/query/table.hpp"
#include "matador/sql/internal/collection_resolver_producer.hpp"
#include "matador/sql/internal/object_resolver_producer.hpp"
#include "matador/sql/producer_resolver_factory.hpp"
#include <memory>
#include <typeindex>
#include <unordered_map>
namespace matador::query {
class schema_node final {
public:
schema_node(class table tab, utils::generator_type generator_type, const object::repository_node& node);
schema_node(class table tab, std::unique_ptr<abstract_pk_generator> &&pk_generator, const object::repository_node& node);
[[nodiscard]] const std::string& name() const;
[[nodiscard]] const class table& table() const;
[[nodiscard]] utils::generator_type generator_type() const;
[[nodiscard]] abstract_pk_generator& pk_generator() const;
[[nodiscard]] const object::repository_node& node() const;
private:
class table table_;
utils::generator_type generator_type_{};
std::unique_ptr<abstract_pk_generator> pk_generator_;
const object::repository_node& node_;
};
@ -33,7 +35,7 @@ class primary_key_generator_finder final {
public:
template< typename Type >
utils::generator_type find(const object::object_info<Type>& info) {
generator_type_ = utils::generator_type::Manually;
generator_type_ = utils::generator_type::Manual;
access::process(*this, info.prototype());

20
include/matador/query/database.hpp Normal file
View File

@ -0,0 +1,20 @@
#ifndef MATADOR_DATABASE_HPP
#define MATADOR_DATABASE_HPP
#include "matador/query/schema.hpp"
#include "matador/utils/result.hpp"
#include "matador/utils/error.hpp"
namespace matador::query {
class database final {
public:
utils::result<void, utils::error> add(const std::string &name, const schema &schema);
utils::result<void, utils::error> remove(const std::string &name);
[[nodiscard]] utils::result<schema_ref, utils::error> get(const std::string &name);
private:
std::unordered_map<std::string, schema> schema_map_;
};
}
#endif //MATADOR_DATABASE_HPP

4
include/matador/query/insert_query_builder.hpp
View File

@ -89,7 +89,7 @@ public:
step_query_t query;
// Session uses these to handle manual/sequence/table pre-insert PKs
utils::generator_type pk_generator{utils::generator_type::Manually};
utils::generator_type pk_generator{utils::generator_type::Manual};
std::string pk_name;
std::function<bool()> pk_is_unset{};
@ -228,7 +228,7 @@ private:
insert_step step{};
if (info.has_primary_key()) {
step.pk_name = info.primary_key_attribute()->name();
step.pk_generator = it->second.generator_type();
step.pk_generator = it->second.pk_generator().type();
step.pk_is_unset = [ptr, name = step.pk_name]() {
pk_unset_checker chk{name};

13
include/matador/query/manual_pk_generator.hpp Normal file
View File

@ -0,0 +1,13 @@
#ifndef MATADOR_MANUAL_PK_GENERATOR_HPP
#define MATADOR_MANUAL_PK_GENERATOR_HPP
#include "matador/query/abstract_pk_generator.hpp"
namespace matador::query {
class manual_pk_generator : public abstract_pk_generator {
public:
manual_pk_generator();
[[nodiscard]] utils::result<int64_t, utils::error> next_id(const sql::executor& exec) override;
};
}
#endif //MATADOR_MANUAL_PK_GENERATOR_HPP

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

@ -183,17 +183,6 @@ class schema;
using schema_ref = std::reference_wrapper<schema>;
class schema_repository final {
public:
utils::result<void, utils::error> add(const std::string &name, const schema &schema);
utils::result<void, utils::error> remove(const std::string &name);
[[nodiscard]] utils::result<schema_ref, utils::error> get(const std::string &name);
private:
std::unordered_map<std::string, schema> schema_map_;
};
template<typename Type>
class schema_observer final : public object::observer<Type> {
public:

16
include/matador/query/table_pk_generator.hpp Normal file
View File

@ -0,0 +1,16 @@
#ifndef MATADOR_TABLE_PK_GENERATOR_HPP
#define MATADOR_TABLE_PK_GENERATOR_HPP
#include "matador/query/abstract_pk_generator.hpp"
namespace matador::query {
class table_pk_generator : public abstract_pk_generator {
public:
table_pk_generator(const std::string& table_name, const std::string& sequence_name);
[[nodiscard]] utils::result<int64_t, utils::error> next_id(const sql::executor& exec) override;
private:
std::string table_name;
};
}
#endif //MATADOR_TABLE_PK_GENERATOR_HPP

2
include/matador/utils/primary_key_attribute.hpp
View File

@ -44,7 +44,7 @@ public:
[[nodiscard]] generator_type generator() const;
private:
size_t size_ = 0;
generator_type generator_ = generator_type::Manually;
generator_type generator_ = generator_type::Manual;
};
const primary_key_attribute default_pk_attributes {};

2
include/matador/utils/primary_key_generator_type.hpp
View File

@ -3,7 +3,7 @@
namespace matador::utils {
enum class generator_type {
Manually, /**< User sets the primary key value manually. */
Manual, /**< User sets the primary key value manually. */
Auto, /**< Matador chooses the best generator type depending on the underlying dbms. */
Identity, /**< DBMS automatically generates the primary key value. */
Sequence, /**< DBMS automatically generates the primary key value by using a sequence table. */

6
source/orm/CMakeLists.txt
View File

@ -192,6 +192,12 @@ add_library(matador-orm STATIC
sql/resolver_service.cpp
sql/statement.cpp
sql/statement_cache.cpp
../../include/matador/query/database.hpp
query/abstract_pk_generator.cpp
../../include/matador/query/manual_pk_generator.hpp
query/manual_pk_generator.cpp
../../include/matador/query/table_pk_generator.hpp
query/table_pk_generator.cpp
)
target_include_directories(matador-orm

10
source/orm/query/abstract_pk_generator.cpp Normal file
View File

@ -0,0 +1,10 @@
#include "matador/query/abstract_pk_generator.hpp"
namespace matador::query {
abstract_pk_generator::abstract_pk_generator(const utils::generator_type type)
: generator_type_{type} {}
utils::generator_type abstract_pk_generator::type() const {
return generator_type_;
}
}

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

@ -3,9 +3,9 @@
#include "matador/sql/executor.hpp"
namespace matador::query {
schema_node::schema_node(class table tab, utils::generator_type generator_type, 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))
, generator_type_(generator_type)
, pk_generator_(std::move(pk_generator))
, node_(std::move(node)) {
}
@ -17,8 +17,8 @@ const table &schema_node::table() const {
return table_;
}
utils::generator_type schema_node::generator_type() const {
return generator_type_;
abstract_pk_generator& schema_node::pk_generator() const {
return *pk_generator_;
}
const object::repository_node& schema_node::node() const {

13
source/orm/query/manual_pk_generator.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "matador/query/manual_pk_generator.hpp"
#include "matador/sql/error_code.hpp"
namespace matador::query {
manual_pk_generator::manual_pk_generator()
: abstract_pk_generator(utils::generator_type::Manual){
}
utils::result<int64_t, utils::error> manual_pk_generator::next_id(const sql::executor &/*exec*/) {
return utils::failure(utils::error(sql::error_code::FAILURE, "Manual PK generator not implemented"));
}
}

5
source/orm/query/sequence_pk_generator.cpp
View File

@ -5,11 +5,12 @@
namespace matador::query {
sequence_pk_generator::sequence_pk_generator(const std::string& sequence_name)
: query_(query::select().nextval(sequence_name)) {
: abstract_pk_generator(utils::generator_type::Sequence)
, query_(query::select().nextval(sequence_name)) {
}
utils::result<int64_t, utils::error> sequence_pk_generator::next_id(const sql::executor& exec) {
return query_.fetch_value<int64_t>(exec).and_then([](std::optional<int64_t> id) -> utils::result<int64_t, utils::error> {
return query_.fetch_value<int64_t>(exec).and_then([](const std::optional<int64_t> id) -> utils::result<int64_t, utils::error> {
if (!id) {
return utils::failure(utils::error(sql::error_code::RETRIEVE_DATA_FAILED, "Sequence returned no value"));
}

22
source/orm/query/table_pk_generator.cpp Normal file
View File

@ -0,0 +1,22 @@
#include "matador/query/table_pk_generator.hpp"
#include "matador/query/query.hpp"
namespace matador::query {
table_pk_generator::table_pk_generator(const std::string& table_name, const std::string &sequence_name)
: abstract_pk_generator(utils::generator_type::Table) {
// query::update(table_name)
// .set("next_id", "next_id + 1")
// .where("name", "=", table_name)
// .returning("next_id - 1 AS id");
/*
*UPDATE id_table
SET next_id = next_id + 1
WHERE name = 'users'
RETURNING next_id - 1 AS id;
*/
}
utils::result<int64_t, utils::error> table_pk_generator::next_id(const sql::executor &exec) {
}
}