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

removed string from restriction

This commit is contained in:
Sascha Kühl 2025-12-09 21:13:47 +01:00
parent c4f8731262
commit 9b7b74524f
13 changed files with 86 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
include/matador/object/attribute.hpp
View File

@ -39,7 +39,7 @@ public:
[[nodiscard]] utils::field_attributes& attributes(); [[nodiscard]] utils::field_attributes& attributes();
[[nodiscard]] bool is_nullable() const; [[nodiscard]] bool is_nullable() const;
[[nodiscard]] utils::basic_type type() const; [[nodiscard]] utils::basic_type type() const;
[[nodiscard]] object* owner() const; [[nodiscard]] std::shared_ptr<object> owner() const;
void change_type(utils::basic_type type, const utils::field_attributes &attr = utils::null_attributes); void change_type(utils::basic_type type, const utils::field_attributes &attr = utils::null_attributes);
template < typename Type > template < typename Type >
void change_type(const utils::field_attributes &attr = utils::null_attributes) { void change_type(const utils::field_attributes &attr = utils::null_attributes) {
@ -69,78 +69,12 @@ private:
friend class object_generator; friend class object_generator;
std::string name_; std::string name_;
object *owner_{nullptr}; std::shared_ptr<object> owner_;
utils::basic_type type_{utils::basic_type::Null}; utils::basic_type type_{utils::basic_type::Null};
utils::field_attributes options_{}; utils::field_attributes options_{};
null_option_type null_option_{null_option_type::NotNull}; null_option_type null_option_{null_option_type::NotNull};
}; };
/**
* User defined literal to have a shortcut creating a column object
* @param name Name of the column
* @param type
* @param attr Length of the column name
* @param null_opt
* @return A column object with a given name
*/
// attribute make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr = utils::null_attributes, null_option_type null_opt = null_option_type::NOT_NULL);
//
// template < typename Type >
// attribute make_column(const std::string &name, utils::field_attributes attr = utils::null_attributes, null_option_type null_opt = null_option_type::NOT_NULL)
// {
// return make_column(name, utils::data_type_traits<Type>::type(0), attr, null_opt);
// }
// template <>
// attribute make_column<std::string>(const std::string &name, utils::field_attributes attr, null_option_type null_opt);
//
// template < typename Type >
// attribute make_pk_column(const std::string &name, size_t size = 0)
// {
// return make_column<Type>(name, { size, utils::constraints::PrimaryKey });
// }
//
// template <>
// attribute make_pk_column<std::string>(const std::string &name, size_t size);
//
// template < typename Type >
// attribute make_fk_column(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column) {
// return {name, utils::data_type_traits<Type>::type(size), ref_column, { size, utils::constraints::ForeignKey }};
// }
//
// template < typename Type >
// [[maybe_unused]] attribute make_fk_column(const std::string &name, const std::shared_ptr<attribute> &ref_column)
// {
// return {name, utils::data_type_traits<Type>::type(0), 0, ref_column, { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL};
// }
//
// template <>
// [[maybe_unused]] attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column);
//
// template < typename Type >
// [[maybe_unused]] attribute make_fk_column(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name) {
// return {
// name, utils::data_type_traits<Type>::type(size), 0,
// std::make_shared<attribute>(ref_column_name, ref_table_name, utils::data_type_traits<Type>::type(size), utils::constraints::ForeignKey),
// { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL
// };
// }
//
// template < typename Type >
// [[maybe_unused]] attribute make_fk_column(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name) {
// return {
// name, utils::data_type_traits<Type>::type(0), 0,
// std::make_shared<attribute>(ref_column_name, utils::data_type_traits<Type>::type(0), ref_table_name, attribute_options{utils::constraints::ForeignKey}),
// { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL
// };
// }
//
// template <>
// [[maybe_unused]] attribute make_fk_column<std::string>(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name);
//
// template <>
// [[maybe_unused]] attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::string &ref_table_name, const std::string &ref_column_name);
} }
#endif //QUERY_COLUMN_DEFINITION_HPP #endif //QUERY_COLUMN_DEFINITION_HPP

10
include/matador/object/attribute_generator.hpp
View File

@ -55,19 +55,19 @@ private:
class attribute_generator final { class attribute_generator final {
private: private:
attribute_generator(std::vector<attribute> &columns, const repository &repo, object &obj); attribute_generator(std::vector<attribute> &columns, const repository &repo, const std::shared_ptr<object>& obj);
public: public:
~attribute_generator() = default; ~attribute_generator() = default;
template < class Type > template < class Type >
static std::vector<attribute> generate(const repository &repo, object &obj) { static std::vector<attribute> generate(const repository &repo, const std::shared_ptr<object> &obj) {
Type t; Type t;
return generate(t, repo, obj); return generate(t, repo, obj);
} }
template < class Type > template < class Type >
static std::vector<attribute> generate(const Type& t, const repository &repo, object &obj) { static std::vector<attribute> generate(const Type& t, const repository &repo, const std::shared_ptr<object> &obj) {
std::vector<attribute> columns; std::vector<attribute> columns;
attribute_generator gen(columns, repo, obj); attribute_generator gen(columns, repo, obj);
access::process(gen, t); access::process(gen, t);
@ -122,7 +122,7 @@ private:
template<typename ValueType> template<typename ValueType>
attribute &emplace_attribute(const char *id, const utils::field_attributes& attr, null_option_type null_option) { attribute &emplace_attribute(const char *id, const utils::field_attributes& attr, null_option_type null_option) {
auto &ref = columns_.emplace_back(id, utils::data_type_traits<ValueType>::type(attr.size()), attr, null_option); auto &ref = columns_.emplace_back(id, utils::data_type_traits<ValueType>::type(attr.size()), attr, null_option);
ref.owner_ = &obj_; ref.owner_ = obj_;
return ref; return ref;
} }
@ -132,7 +132,7 @@ private:
size_t index_ = 0; size_t index_ = 0;
std::vector<attribute> &columns_; std::vector<attribute> &columns_;
const repository &repo_; const repository &repo_;
object &obj_; const std::shared_ptr<object> obj_;
fk_attribute_generator fk_column_generator_; fk_attribute_generator fk_column_generator_;
}; };

5
include/matador/object/object.hpp
View File

@ -17,10 +17,7 @@ class object {
public: public:
explicit object(std::string name, std::string alias = ""); explicit object(std::string name, std::string alias = "");
static const attribute& create_attribute(std::string name, object& obj); static const attribute& create_attribute(std::string name, const std::shared_ptr<object>& obj);
// void add_attribute(attribute attr);
// void add_constraint(class constraint c);
[[nodiscard]] attribute* primary_key_attribute() const; [[nodiscard]] attribute* primary_key_attribute() const;
[[nodiscard]] const utils::identifier& primary_key() const; [[nodiscard]] const utils::identifier& primary_key() const;

6
include/matador/object/object_generator.hpp
View File

@ -88,7 +88,7 @@ public:
void on_foreign_key(const char *id, Pointer &/*x*/) { void on_foreign_key(const char *id, Pointer &/*x*/) {
const auto type = pk_type_determinator::determine<typename Pointer::value_type>(); const auto type = pk_type_determinator::determine<typename Pointer::value_type>();
auto &ref = object_->attributes_.emplace_back(id, type, utils::constraints::ForeignKey, null_option_type::NotNull); auto &ref = object_->attributes_.emplace_back(id, type, utils::constraints::ForeignKey, null_option_type::NotNull);
ref.owner_ = object_.get(); ref.owner_ = object_;
} }
template<class ContainerType> template<class ContainerType>
static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {} static void on_has_many(const char * /*id*/, ContainerType &, const char *, const utils::foreign_attributes &/*attr*/) {}
@ -101,7 +101,7 @@ private:
template<typename ValueType> template<typename ValueType>
attribute &emplace_attribute(const char *id, const utils::field_attributes& attr, null_option_type null_option) { attribute &emplace_attribute(const char *id, const utils::field_attributes& attr, null_option_type null_option) {
auto &ref = object_->attributes_.emplace_back(id, utils::data_type_traits<ValueType>::type(attr.size()), attr, null_option); auto &ref = object_->attributes_.emplace_back(id, utils::data_type_traits<ValueType>::type(attr.size()), attr, null_option);
ref.owner_ = object_.get(); ref.owner_ = object_;
return ref; return ref;
} }
@ -113,7 +113,7 @@ private:
void prepare_primary_key(attribute &ref, utils::identifier &&pk) const; void prepare_primary_key(attribute &ref, utils::identifier &&pk) const;
std::shared_ptr<class object> fk_object(const std::type_index& ti) const; [[nodiscard]] std::shared_ptr<class object> fk_object(const std::type_index& ti) const;
private: private:
repository &repo_; repository &repo_;

36
include/matador/object/restriction.hpp
View File

@ -43,28 +43,24 @@ private:
std::shared_ptr<object> owner_; std::shared_ptr<object> owner_;
std::shared_ptr<object> reference_; std::shared_ptr<object> reference_;
utils::constraints options_{utils::constraints::None}; utils::constraints options_{utils::constraints::None};
std::string ref_table_name_{};
std::string ref_column_name_{};
}; };
class constraint_builder { // class constraint_builder {
public: // public:
constraint_builder& constraint(std::string name); // constraint_builder& constraint(std::string name);
constraint_builder& primary_key(std::string name); // constraint_builder& primary_key(std::string name);
constraint_builder& foreign_key(std::string name); // constraint_builder& foreign_key(std::string name);
constraint_builder& references(std::string table, std::string column); // constraint_builder& references(std::string table, std::string column);
//
operator class restriction() const; // operator class restriction() const;
//
private: // private:
std::string constraint_name; // std::string constraint_name;
utils::constraints options_{utils::constraints::None}; // utils::constraints options_{utils::constraints::None};
std::string column_name; // std::string column_name;
std::string ref_table_name; // };
std::string ref_column_name; //
}; // constraint_builder constraint(std::string name);
constraint_builder constraint(std::string name);
} }
#endif //MATADOR_CONSTRAINT_HPP #endif //MATADOR_CONSTRAINT_HPP

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

@ -64,9 +64,9 @@ using Boolean = typed_data_type<bool>;
using Varchar = sized_typed_data_type<std::string>; using Varchar = sized_typed_data_type<std::string>;
using Blob = sized_typed_data_type<std::vector<std::byte>>; using Blob = sized_typed_data_type<std::vector<std::byte>>;
class restriction { class constraint {
public: public:
explicit restriction(std::string name) explicit constraint(std::string name)
: name_(std::move(name)) {} : name_(std::move(name)) {}
[[nodiscard]] const std::string& name() const; [[nodiscard]] const std::string& name() const;
@ -126,7 +126,7 @@ public:
constraint_builder& references(std::string table, std::string column); constraint_builder& references(std::string table, std::string column);
// ReSharper disable once CppNonExplicitConversionOperator // ReSharper disable once CppNonExplicitConversionOperator
operator object::restriction() const; // NOLINT(*-explicit-constructor) operator object::constraint() const; // NOLINT(*-explicit-constructor)
private: private:
std::string constraint_name; std::string constraint_name;

2
source/core/object/attribute.cpp
View File

@ -47,7 +47,7 @@ utils::basic_type attribute::type() const {
return type_; return type_;
} }
object* attribute::owner() const { std::shared_ptr<object> attribute::owner() const {
return owner_; return owner_;
} }

8
source/core/object/attribute_generator.cpp
View File

@ -4,14 +4,14 @@
namespace matador::object { namespace matador::object {
attribute_generator::attribute_generator(std::vector<attribute> &columns, const repository &repo, object &obj) attribute_generator::attribute_generator(std::vector<attribute> &columns, const repository &repo, const std::shared_ptr<object> &obj)
: columns_(columns) : columns_(columns)
, repo_(repo) , repo_(repo)
, obj_(obj) , obj_(obj)
{} {}
void attribute_generator::on_revision(const char *id, uint64_t &rev) { void attribute_generator::on_revision(const char *id, uint64_t &rev) {
on_attribute(id, rev); on_attribute(id, rev);
} }
utils::result<attribute*, utils::error> attribute_generator::determine_foreign_ref(const std::type_index &ti) const { utils::result<attribute*, utils::error> attribute_generator::determine_foreign_ref(const std::type_index &ti) const {
@ -23,7 +23,7 @@ void attribute_generator::insert_missing_reference_column(const std::type_index&
} }
void attribute_generator::prepare_primary_key(attribute& ref, utils::identifier &&pk) const { void attribute_generator::prepare_primary_key(attribute& ref, utils::identifier &&pk) const {
obj_.pk_attribute_ = &ref; obj_->pk_attribute_ = &ref;
obj_.pk_identifier_ = std::move(pk); obj_->pk_identifier_ = std::move(pk);
} }
} }

7
source/core/object/constraints_generator.cpp
View File

@ -11,7 +11,7 @@ constraints_generator::constraints_generator(std::list<class restriction> &const
, obj_(obj) {} , obj_(obj) {}
void constraints_generator::create_pk_constraint(const std::string& name) const { void constraints_generator::create_pk_constraint(const std::string& name) const {
class restriction pk_constraint("PK_" + obj_->name()); restriction pk_constraint("PK_" + obj_->name());
pk_constraint.options_ |= utils::constraints::PrimaryKey; pk_constraint.options_ |= utils::constraints::PrimaryKey;
if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(obj_->attributes_)) { if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(obj_->attributes_)) {
pk_constraint.attr_ = &*pk_attr; pk_constraint.attr_ = &*pk_attr;
@ -25,15 +25,12 @@ void constraints_generator::create_fk_constraint(const std::type_index& ti, cons
if (!result) { if (!result) {
return; return;
} }
const auto *pk_attribute = result.value().get().primary_key_attribute(); restriction pk_constraint("FK_" + obj_->name() + "_" + name);
class restriction pk_constraint("FK_" + obj_->name() + "_" + name);
pk_constraint.options_ |= utils::constraints::ForeignKey; pk_constraint.options_ |= utils::constraints::ForeignKey;
if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(obj_->attributes_)) { if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(obj_->attributes_)) {
pk_constraint.attr_ = &*pk_attr; pk_constraint.attr_ = &*pk_attr;
} }
pk_constraint.owner_ = obj_; pk_constraint.owner_ = obj_;
pk_constraint.ref_column_name_ = pk_attribute->name();
pk_constraint.ref_table_name_ = pk_attribute->owner() ? pk_attribute->owner()->name() : "";
constraints_.emplace_back(std::move(pk_constraint)); constraints_.emplace_back(std::move(pk_constraint));
} }

6
source/core/object/object.cpp
View File

@ -5,10 +5,10 @@ object::object( std::string name, std::string alias )
: name_(std::move(name)) : name_(std::move(name))
, alias_(std::move(alias)) {} , alias_(std::move(alias)) {}
const attribute& object::create_attribute( std::string name, object& obj ) { const attribute& object::create_attribute(std::string name, const std::shared_ptr<object>& obj) {
attribute attr{std::move(name)}; attribute attr{std::move(name)};
attr.owner_ = &obj; attr.owner_ = obj;
return obj.attributes_.emplace_back(std::move(attr)); return obj->attributes_.emplace_back(std::move(attr));
} }
// void object::add_attribute( attribute attr ) { // void object::add_attribute( attribute attr ) {

11
source/core/object/object_generator.cpp
View File

@ -14,7 +14,7 @@ void object_generator::on_revision(const char* id, uint64_t& rev) {
} }
void object_generator::create_pk_constraint(const std::string& name) const { void object_generator::create_pk_constraint(const std::string& name) const {
class restriction pk_constraint("PK_" + object_->name()); restriction pk_constraint("PK_" + object_->name());
pk_constraint.options_ |= utils::constraints::PrimaryKey; pk_constraint.options_ |= utils::constraints::PrimaryKey;
if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) { if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) {
pk_constraint.attr_ = &*pk_attr; pk_constraint.attr_ = &*pk_attr;
@ -25,23 +25,18 @@ void object_generator::create_pk_constraint(const std::string& name) const {
void object_generator::create_fk_constraint(const std::type_index& ti, const std::string& name) const { void object_generator::create_fk_constraint(const std::type_index& ti, const std::string& name) const {
const auto obj = fk_object(ti); const auto obj = fk_object(ti);
const auto *pk_attribute = obj->primary_key_attribute(); restriction pk_constraint("FK_" + object_->name() + "_" + name);
class restriction pk_constraint("FK_" + object_->name() + "_" + name);
pk_constraint.options_ |= utils::constraints::ForeignKey; pk_constraint.options_ |= utils::constraints::ForeignKey;
if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) { if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) {
pk_constraint.attr_ = &*pk_attr; pk_constraint.attr_ = &*pk_attr;
} }
pk_constraint.owner_ = object_; pk_constraint.owner_ = object_;
pk_constraint.reference_ = obj; pk_constraint.reference_ = obj;
if (pk_attribute) {
pk_constraint.ref_column_name_ = pk_attribute->name();
pk_constraint.ref_table_name_ = pk_attribute->owner() ? pk_attribute->owner()->name() : "";
}
object_->constraints_.emplace_back(std::move(pk_constraint)); object_->constraints_.emplace_back(std::move(pk_constraint));
} }
void object_generator::create_unique_constraint(const std::string& name) const { void object_generator::create_unique_constraint(const std::string& name) const {
class restriction pk_constraint("UK_" + object_->name() + "_" + name); restriction pk_constraint("UK_" + object_->name() + "_" + name);
pk_constraint.options_ |= utils::constraints::Unique; pk_constraint.options_ |= utils::constraints::Unique;
if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) { if (const auto pk_attr = find_attribute_by_name(name); pk_attr != std::end(object_->attributes_)) {
pk_constraint.attr_ = &*pk_attr; pk_constraint.attr_ = &*pk_attr;

81
source/core/object/restriction.cpp
View File

@ -1,6 +1,7 @@
#include "matador/object/restriction.hpp" #include "matador/object/restriction.hpp"
#include "matador/object/attribute.hpp" #include "matador/object/attribute.hpp"
#include "matador/object/object.hpp"
namespace matador::object { namespace matador::object {
restriction::restriction(std::string name) restriction::restriction(std::string name)
@ -46,11 +47,11 @@ bool restriction::is_unique_constraint() const {
} }
const std::string& restriction::ref_table_name() const { const std::string& restriction::ref_table_name() const {
return ref_table_name_; return reference_->name();
} }
const std::string& restriction::ref_column_name() const { const std::string& restriction::ref_column_name() const {
return ref_column_name_; return reference_->primary_key_attribute()->name();
} }
std::ostream & operator<<(std::ostream &os, const class restriction &c) { std::ostream & operator<<(std::ostream &os, const class restriction &c) {
@ -58,42 +59,42 @@ std::ostream & operator<<(std::ostream &os, const class restriction &c) {
return os; return os;
} }
constraint_builder & constraint_builder::constraint(std::string name) { // constraint_builder & constraint_builder::constraint(std::string name) {
constraint_name = std::move(name); // constraint_name = std::move(name);
return *this; // return *this;
} // }
//
constraint_builder & constraint_builder::primary_key(std::string name) { // constraint_builder & constraint_builder::primary_key(std::string name) {
column_name = std::move(name); // column_name = std::move(name);
options_ |= utils::constraints::PrimaryKey; // options_ |= utils::constraints::PrimaryKey;
return *this; // return *this;
} // }
//
constraint_builder & constraint_builder::foreign_key(std::string name) { // constraint_builder & constraint_builder::foreign_key(std::string name) {
column_name = std::move(name); // column_name = std::move(name);
options_ |= utils::constraints::ForeignKey; // options_ |= utils::constraints::ForeignKey;
return *this; // return *this;
} // }
//
constraint_builder & constraint_builder::references(std::string table, std::string column) { // constraint_builder & constraint_builder::references(std::string table, std::string column) {
ref_table_name = std::move(table); // ref_table_name = std::move(table);
ref_column_name = std::move(column); // ref_column_name = std::move(column);
//
return *this; // return *this;
} // }
//
constraint_builder::operator class restriction() const { // constraint_builder::operator class restriction() const {
class restriction c; // class restriction c;
c.name_ = constraint_name; // c.name_ = constraint_name;
c.attr_ = column_name; // c.attr_ = column_name;
c.options_ = options_; // c.options_ = options_;
c.ref_column_name_ = ref_column_name; // c.ref_column_name_ = ref_column_name;
c.ref_table_name_ = ref_table_name; // c.ref_table_name_ = ref_table_name;
return c; // return c;
} // }
//
constraint_builder constraint(std::string name) { // constraint_builder constraint(std::string name) {
constraint_builder builder; // constraint_builder builder;
return builder.constraint(std::move(name)); // return builder.constraint(std::move(name));
} // }
} }

4
test/core/object/AttributeGeneratorTest.cpp
View File

@ -18,7 +18,7 @@ TEST_CASE("Generate column definitions from object", "[column][definition][gener
.and_then([&repo] { return repo.attach<matador::test::category>("categories"); }); .and_then([&repo] { return repo.attach<matador::test::category>("categories"); });
REQUIRE(result); REQUIRE(result);
object obj("products"); auto obj = std::make_shared<object>("products");
auto columns = attribute_generator::generate<matador::test::product>(repo, obj); auto columns = attribute_generator::generate<matador::test::product>(repo, obj);
const std::vector expected_columns = { const std::vector expected_columns = {
@ -45,7 +45,7 @@ TEST_CASE("Generate column definitions from object", "[column][definition][gener
TEST_CASE("Generate columns from object with nullable columns", "[column generator]") { TEST_CASE("Generate columns from object with nullable columns", "[column generator]") {
repository repo("main"); repository repo("main");
object obj("optionals"); auto obj = std::make_shared<object>("optionals");
auto columns = attribute_generator::generate<matador::test::optional>(repo, obj); auto columns = attribute_generator::generate<matador::test::optional>(repo, obj);
const std::vector expected_columns = { const std::vector expected_columns = {