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

Compare commits

base: sascha:ede5a8c6364051fd866b699d3328870218d3564e
Branches Tags
sascha:main
sascha:feature/matador-ng
..
compare: sascha:f47b3bb87f0a7a5f4eee92f6f490b948a2731e6d
Branches Tags
sascha:feature/matador-ng
sascha:main

2 Commits
ede5a8c636 ... f47b3bb87f

Author SHA1 Message Date
Sascha Kühl f47b3bb87f object generating progress 2025-11-25 16:27:25 +01:00
Sascha Kühl ab7a2db869 added pk information to class object 2025-11-25 08:54:58 +01:00
17 changed files with 247 additions and 256 deletions
Show Stats Expand all files Collapse all files

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

@ -23,7 +23,6 @@ class attribute_generator;
class attribute { class attribute {
public: public:
explicit attribute(const char *name); // NOLINT(*-explicit-constructor)
explicit attribute(std::string name); // NOLINT(*-explicit-constructor) explicit attribute(std::string name); // NOLINT(*-explicit-constructor)
attribute(const attribute&) = default; attribute(const attribute&) = default;
@ -35,24 +34,8 @@ public:
attribute(std::string name, attribute(std::string name,
utils::basic_type type, utils::basic_type type,
const utils::field_attributes&, const utils::field_attributes&,
null_option_type null_opt,
int index = 0);
attribute(std::string name,
utils::basic_type type,
int index,
const std::shared_ptr<attribute> &ref_column,
const utils::field_attributes& attr,
null_option_type null_opt); null_option_type null_opt);
attribute(std::string name,
utils::basic_type type,
const std::shared_ptr<attribute> &ref_column = {});
attribute(std::string name,
utils::basic_type type,
std::string table_name,
const attribute_options& options,
const std::shared_ptr<attribute> &ref_column = {});
[[nodiscard]] const std::string& name() const; [[nodiscard]] const std::string& name() const;
void name(const std::string& n); void name(const std::string& n);
[[nodiscard]] std::string full_name() const; [[nodiscard]] std::string full_name() const;
@ -61,15 +44,14 @@ 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]] const std::string& table_name() const; [[nodiscard]] object* owner() const;
void table_name(const std::string& name); // [[nodiscard]] const std::string& table_name() const;
// void table_name(const std::string& name);
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) {
type_ = utils::data_type_traits<Type>::type(attr.size()); type_ = utils::data_type_traits<Type>::type(attr.size());
} }
[[nodiscard]] std::shared_ptr<attribute> reference_column() const;
[[nodiscard]] bool is_foreign_reference() const;
[[nodiscard]] bool is_integer() const; [[nodiscard]] bool is_integer() const;
[[nodiscard]] bool is_floating_point() const; [[nodiscard]] bool is_floating_point() const;
@ -92,11 +74,8 @@ private:
std::string name_; std::string name_;
object *owner_{nullptr}; object *owner_{nullptr};
std::string table_name_;
attribute_options options_; attribute_options options_;
utils::basic_type type_{utils::basic_type::type_null}; utils::basic_type type_{utils::basic_type::type_null};
std::shared_ptr<attribute> reference_column_;
}; };
@ -108,62 +87,62 @@ private:
* @param null_opt * @param null_opt
* @return A column object with a given name * @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); // 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 > // 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) // 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); // return make_column(name, utils::data_type_traits<Type>::type(0), attr, null_opt);
} // }
template <> // template <>
attribute make_column<std::string>(const std::string &name, utils::field_attributes attr, null_option_type null_opt); // attribute make_column<std::string>(const std::string &name, utils::field_attributes attr, null_option_type null_opt);
//
template < typename Type > // template < typename Type >
attribute make_pk_column(const std::string &name, size_t size = 0) // attribute make_pk_column(const std::string &name, size_t size = 0)
{ // {
return make_column<Type>(name, { size, utils::constraints::PrimaryKey }); // return make_column<Type>(name, { size, utils::constraints::PrimaryKey });
} // }
//
template <> // template <>
attribute make_pk_column<std::string>(const std::string &name, size_t size); // attribute make_pk_column<std::string>(const std::string &name, size_t size);
//
template < typename Type > // template < typename Type >
attribute make_fk_column(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column) { // 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 }}; // return {name, utils::data_type_traits<Type>::type(size), ref_column, { size, utils::constraints::ForeignKey }};
} // }
//
template < typename Type > // template < typename Type >
[[maybe_unused]] attribute make_fk_column(const std::string &name, const std::shared_ptr<attribute> &ref_column) // [[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}; // return {name, utils::data_type_traits<Type>::type(0), 0, ref_column, { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL};
} // }
//
template <> // template <>
[[maybe_unused]] attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column); // [[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 > // 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) { // [[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 { // return {
name, utils::data_type_traits<Type>::type(size), 0, // 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), // 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 // { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL
}; // };
} // }
//
template < typename Type > // 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) { // [[maybe_unused]] attribute make_fk_column(const std::string &name, const std::string &ref_table_name, const std::string &ref_column_name) {
return { // return {
name, utils::data_type_traits<Type>::type(0), 0, // 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}), // 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 // { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL
}; // };
} // }
//
template <> // 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); // [[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 <> // 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); // [[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);
} }

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

@ -7,6 +7,7 @@
#include "matador/utils/data_type_traits.hpp" #include "matador/utils/data_type_traits.hpp"
#include "matador/utils/error.hpp" #include "matador/utils/error.hpp"
#include "matador/utils/field_attributes.hpp" #include "matador/utils/field_attributes.hpp"
#include "matador/utils/identifier.hpp"
#include "matador/utils/primary_key_attribute.hpp" #include "matador/utils/primary_key_attribute.hpp"
#include "matador/utils/result.hpp" #include "matador/utils/result.hpp"
@ -91,18 +92,16 @@ public:
on_foreign_key(id, x); on_foreign_key(id, x);
} }
template<class Pointer> template<class Pointer>
void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) { static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
// on_foreign_key(id, x);
}
template <class Pointer> template <class Pointer>
void on_foreign_key(const char *id, Pointer &x) { void on_foreign_key(const char *id, Pointer &x) {
std::shared_ptr<attribute> ref_column; attribute* ref_column;
std::type_index ti = typeid(typename Pointer::value_type); std::type_index ti = typeid(typename Pointer::value_type);
if (const auto result = determine_foreign_ref(std::type_index(ti))) { if (auto result = determine_foreign_ref(std::type_index(ti))) {
ref_column = *result; ref_column = *result;
} else { } else {
ref_column = std::make_shared<attribute>(); ref_column = nullptr;
insert_missing_reference_column(ti, ref_column); insert_missing_reference_column(ti, ref_column);
} }
if (x.empty()) { if (x.empty()) {
@ -120,8 +119,17 @@ public:
static void on_has_many_to_many(const char * /*id*/, ContainerType & /*cont*/, const utils::foreign_attributes &/*attr*/) {} static void on_has_many_to_many(const char * /*id*/, ContainerType & /*cont*/, const utils::foreign_attributes &/*attr*/) {}
private: private:
[[nodiscard]] utils::result<std::shared_ptr<attribute>, utils::error> determine_foreign_ref(const std::type_index &ti) const; [[nodiscard]] utils::result<attribute*, utils::error> determine_foreign_ref(const std::type_index &ti) const;
void insert_missing_reference_column(const std::type_index &ti, const std::shared_ptr<attribute>& ref_column) const; void insert_missing_reference_column(const std::type_index &ti, attribute* ref_column) const;
template<typename ValueType>
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);
ref.owner_ = &obj_;
return ref;
}
void prepare_primary_key(attribute &ref, utils::identifier &&pk) const;
private: private:
size_t index_ = 0; size_t index_ = 0;
@ -134,19 +142,18 @@ private:
template<typename ValueType> template<typename ValueType>
void attribute_generator::on_primary_key(const char *id, ValueType &x, const utils::primary_key_attribute& attr) { void attribute_generator::on_primary_key(const char *id, ValueType &x, const utils::primary_key_attribute& attr) {
on_attribute(id, x, { attr.size(), utils::constraints::PrimaryKey }); auto &ref = emplace_attribute<ValueType>(id, { attr.size(), utils::constraints::PrimaryKey }, null_option_type::NOT_NULL);
prepare_primary_key(ref, utils::identifier(x));
} }
template<typename Type> template<typename Type>
void attribute_generator::on_attribute(const char *id, Type &/*x*/, const utils::field_attributes &attr) { void attribute_generator::on_attribute(const char *id, Type &/*x*/, const utils::field_attributes &attr) {
auto &ref = columns_.emplace_back(id, utils::data_type_traits<Type>::type(attr.size()), attr, null_option_type::NOT_NULL); std::ignore = emplace_attribute<Type>(id, attr, null_option_type::NOT_NULL);
ref.owner_ = &obj_;
} }
template<typename Type> template<typename Type>
void attribute_generator::on_attribute(const char *id, std::optional<Type> & /*x*/, const utils::field_attributes &attr) { void attribute_generator::on_attribute(const char *id, std::optional<Type> & /*x*/, const utils::field_attributes &attr) {
auto &ref = columns_.emplace_back(id, utils::data_type_traits<Type>::type(attr.size()), attr, null_option_type::NULLABLE); std::ignore = emplace_attribute<Type>(id, attr, null_option_type::NULLABLE);
ref.owner_ = &obj_;
} }
} }

12
include/matador/object/basic_object_info.hpp
View File

@ -25,10 +25,11 @@ public:
[[nodiscard]] std::type_index type_index() const; [[nodiscard]] std::type_index type_index() const;
[[nodiscard]] std::string name() const; [[nodiscard]] std::string name() const;
[[nodiscard]] const std::vector<attribute>& attributes() const; [[nodiscard]] const std::vector<attribute>& attributes() const;
[[nodiscard]] std::shared_ptr<attribute> reference_column() const; // [[nodiscard]] std::shared_ptr<attribute> reference_column() const;
[[nodiscard]] bool has_primary_key() const; [[nodiscard]] bool has_primary_key() const;
[[nodiscard]] const utils::identifier& primary_key() const; [[nodiscard]] const utils::identifier& primary_key() const;
[[nodiscard]] attribute* primary_key_attribute() const;
endpoint_iterator register_relation_endpoint(const std::type_index &type, const std::shared_ptr<relation_endpoint> &endpoint); endpoint_iterator register_relation_endpoint(const std::type_index &type, const std::shared_ptr<relation_endpoint> &endpoint);
void unregister_relation_endpoint(const std::type_index &type); void unregister_relation_endpoint(const std::type_index &type);
@ -49,14 +50,13 @@ public:
[[nodiscard]] bool endpoints_empty() const; [[nodiscard]] bool endpoints_empty() const;
protected: protected:
basic_object_info(std::shared_ptr<repository_node> node, const std::vector<attribute> &attributes, utils::identifier &&pk, const std::shared_ptr<attribute> &pk_as_fk_column); // basic_object_info(std::shared_ptr<repository_node> node, const std::vector<attribute> &attributes, utils::identifier &&pk, const std::shared_ptr<attribute> &pk_as_fk_column);
basic_object_info(std::shared_ptr<repository_node> node, const std::vector<attribute> &attributes); // basic_object_info(std::shared_ptr<repository_node> node, const std::vector<attribute> &attributes);
basic_object_info(std::shared_ptr<repository_node> node, std::unique_ptr<object> &&obj);
protected: protected:
std::unique_ptr<object> object_;
std::shared_ptr<repository_node> node_; /**< prototype node of the represented object type */ std::shared_ptr<repository_node> node_; /**< prototype node of the represented object type */
std::vector<attribute> attributes_;
std::optional<utils::identifier> identifier_;
std::shared_ptr<attribute> pk_as_fk_column_;
t_endpoint_map relation_endpoints_; t_endpoint_map relation_endpoints_;
}; };

1
include/matador/object/error_code.hpp
View File

@ -10,6 +10,7 @@ enum class error_code : uint8_t {
OK = 0, OK = 0,
NodeNotFound = 1, NodeNotFound = 1,
NodeAlreadyExists = 2, NodeAlreadyExists = 2,
NoPrimaryKey = 3,
Failure, Failure,
}; };

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

@ -6,6 +6,8 @@
#include "matador/object/constraint.hpp" #include "matador/object/constraint.hpp"
#include "matador/object/constraints_generator.hpp" #include "matador/object/constraints_generator.hpp"
#include "matador/utils/identifier.hpp"
namespace matador::object { namespace matador::object {
class repository; class repository;
@ -27,9 +29,15 @@ public:
void add_attribute(attribute attr); void add_attribute(attribute attr);
void add_constraint(class constraint c); void add_constraint(class constraint c);
[[nodiscard]] attribute* primary_key_attribute() const;
[[nodiscard]] const utils::identifier& primary_key() const;
[[nodiscard]] bool has_primary_key() const;
[[nodiscard]] const std::string& name() const; [[nodiscard]] const std::string& name() const;
[[nodiscard]] const std::string& alias() const; [[nodiscard]] const std::string& alias() const;
void update_name(const std::string& name);
[[nodiscard]] bool has_attributes() const; [[nodiscard]] bool has_attributes() const;
[[nodiscard]] size_t attribute_count() const; [[nodiscard]] size_t attribute_count() const;
[[nodiscard]] const std::vector<attribute>& attributes() const; [[nodiscard]] const std::vector<attribute>& attributes() const;
@ -40,10 +48,13 @@ public:
private: private:
friend class constraints_generator; friend class constraints_generator;
friend class attribute_generator;
std::string name_; std::string name_;
std::string alias_; std::string alias_;
attribute* pk_attribute_{nullptr};
utils::identifier pk_identifier_;
std::vector<attribute> attributes_; std::vector<attribute> attributes_;
std::vector<class constraint> constraints_; std::vector<class constraint> constraints_;
}; };

13
include/matador/object/object_info.hpp
View File

@ -12,19 +12,12 @@ public:
using create_func = std::function<std::unique_ptr<Type>()>; using create_func = std::function<std::unique_ptr<Type>()>;
object_info(const std::shared_ptr<repository_node>& node, object_info(const std::shared_ptr<repository_node>& node,
const std::vector<attribute> &attributes, std::unique_ptr<object> &&obj,
utils::identifier &&pk,
const std::shared_ptr<attribute> &ref_column,
create_func&& creator) create_func&& creator)
: basic_object_info(node, attributes, std::move(pk), ref_column) : basic_object_info(node, std::move(obj))
, creator_(std::move(creator)){
}
object_info(const std::shared_ptr<repository_node>& node,
const std::vector<attribute> &attributes,
create_func&& creator)
: basic_object_info(node, attributes)
, creator_(std::move(creator)){ , creator_(std::move(creator)){
} }
explicit object_info(const std::shared_ptr<repository_node>& node) explicit object_info(const std::shared_ptr<repository_node>& node)
: basic_object_info(node, {}) { : basic_object_info(node, {}) {
} }

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

@ -151,8 +151,7 @@ public:
return utils::ok(basic_object_info_ref{result.value()->info()}); return utils::ok(basic_object_info_ref{result.value()->info()});
} }
[[nodiscard]] utils::result<std::shared_ptr<attribute>, utils::error> reference_column( [[nodiscard]] utils::result<attribute*, utils::error> primary_key_attribute(const std::type_index &type_index) const;
const std::type_index &type_index) const;
void dump(std::ostream &os) const; void dump(std::ostream &os) const;
static void dump(std::ostream &os, const node_ptr& node); static void dump(std::ostream &os, const node_ptr& node);
@ -188,7 +187,7 @@ private:
t_type_index_node_map nodes_by_type_; t_type_index_node_map nodes_by_type_;
logger::logger log_; logger::logger log_;
std::unordered_map<std::type_index, std::shared_ptr<attribute> > missing_references_; std::unordered_map<std::type_index, attribute*> missing_references_;
}; };
} }

7
include/matador/object/repository_node.hpp
View File

@ -28,10 +28,7 @@ public:
const auto attributes = attribute_generator::generate<Type>(repo, *obj); const auto attributes = attribute_generator::generate<Type>(repo, *obj);
auto info = std::make_unique<object_info<Type>>( auto info = std::make_unique<object_info<Type>>(
node, node,
attributes, std::move(obj),
std::move(pk_info.pk),
ref_column,
// obj,
[]{ return std::make_unique<Type>(); } []{ return std::make_unique<Type>(); }
); );
node->info_ = std::move(info); node->info_ = std::move(info);
@ -93,7 +90,7 @@ private:
void unlink(); void unlink();
static utils::result<node_ptr, utils::error> make_and_attach_node(repository& repo, const std::string& name, const std::type_index& ti); static utils::result<node_ptr, utils::error> make_and_attach_node(repository& repo, const std::string& name, const std::type_index& ti);
static std::shared_ptr<attribute> determine_reference_column(const std::type_index& ti, static attribute* determine_reference_column(const std::type_index& ti,
const std::string& table_name, const std::string& table_name,
const primary_key_info& pk_info, const primary_key_info& pk_info,
repository& repo); repository& repo);

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

@ -1,49 +1,22 @@
#include "matador/object/attribute.hpp" #include "matador/object/attribute.hpp"
#include "matador/object/object.hpp"
#include <ostream> #include <ostream>
#include <utility> #include <utility>
namespace matador::object { namespace matador::object {
attribute::attribute(const char *name)
: attribute(name, utils::basic_type::type_null, "", {utils::null_attributes}) {
}
attribute::attribute(std::string name) attribute::attribute(std::string name)
: attribute(std::move(name), utils::basic_type::type_null, "", {utils::null_attributes}) { : attribute(std::move(name), utils::basic_type::type_null, {}, null_option_type::NOT_NULL) {
} }
attribute::attribute(std::string name, attribute::attribute(std::string name,
const utils::basic_type type, const utils::basic_type type,
const utils::field_attributes &attr, const utils::field_attributes &attr,
const null_option_type null_opt,
const int index)
: attribute(std::move(name), type, "", {attr, null_opt, index}) {
}
attribute::attribute(std::string name,
const utils::basic_type type,
const int index,
const std::shared_ptr<attribute> &ref_column,
const utils::field_attributes &attr,
const null_option_type null_opt) const null_option_type null_opt)
: attribute(std::move(name), type, "", {attr, null_opt, index}, ref_column) {
}
attribute::attribute( std::string name, const utils::basic_type type, const std::shared_ptr<attribute>& ref_column )
: attribute(std::move(name), type, {}, {}, ref_column) {
}
attribute::attribute(std::string name,
const utils::basic_type type,
std::string table_name,
const attribute_options& options,
const std::shared_ptr<attribute>& ref_column)
: name_(std::move(name)) : name_(std::move(name))
, table_name_(std::move(table_name)) , options_{attr, null_opt}
, options_( options )
, type_(type) , type_(type)
, reference_column_( ref_column ) { {}
}
const std::string &attribute::name() const { const std::string &attribute::name() const {
return name_; return name_;
@ -54,7 +27,7 @@ void attribute::name( const std::string& n ) {
} }
std::string attribute::full_name() const { std::string attribute::full_name() const {
return !table_name_.empty() ? table_name_ + "." + name_ : name_; return owner_ ? owner_->name() + "." + name_ : name_;
} }
int attribute::index() const { int attribute::index() const {
@ -77,27 +50,23 @@ utils::basic_type attribute::type() const {
return type_; return type_;
} }
const std::string& attribute::table_name() const { object* attribute::owner() const {
return table_name_; return owner_;
} }
void attribute::table_name( const std::string& name ) { // const std::string& attribute::table_name() const {
table_name_ = name; // return owner_ ? owner_->name() : "";
} // }
//
// void attribute::table_name( const std::string& name ) {
// table_name_ = name;
// }
void attribute::change_type(const utils::basic_type type, const utils::field_attributes& attr) { void attribute::change_type(const utils::basic_type type, const utils::field_attributes& attr) {
options_.attributes = attr; options_.attributes = attr;
type_ = type; type_ = type;
} }
std::shared_ptr<attribute> attribute::reference_column() const {
return reference_column_;
}
bool attribute::is_foreign_reference() const {
return reference_column_ != nullptr;
}
bool attribute::is_integer() const { bool attribute::is_integer() const {
return type_ >= utils::basic_type::type_int8 && type_ <= utils::basic_type::type_uint64; return type_ >= utils::basic_type::type_int8 && type_ <= utils::basic_type::type_uint64;
} }
@ -134,45 +103,45 @@ bool attribute::is_null() const {
return type_ == utils::basic_type::type_null; return type_ == utils::basic_type::type_null;
} }
attribute make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr, // attribute make_column(const std::string &name, utils::basic_type type, utils::field_attributes attr,
null_option_type null_opt) { // null_option_type null_opt) {
return {name, type, attr, null_opt}; // return {name, type, attr, null_opt};
} // }
//
template<> // template<>
attribute make_column<std::string>(const std::string &name, utils::field_attributes attr, // attribute make_column<std::string>(const std::string &name, utils::field_attributes attr,
null_option_type null_opt) { // null_option_type null_opt) {
return make_column(name, utils::data_type_traits<std::string>::type(attr.size()), attr, null_opt); // return make_column(name, utils::data_type_traits<std::string>::type(attr.size()), attr, null_opt);
} // }
//
template<> // template<>
attribute make_pk_column<std::string>(const std::string &name, size_t size) { // attribute make_pk_column<std::string>(const std::string &name, size_t size) {
return make_column<std::string>(name, {size, utils::constraints::PrimaryKey}); // return make_column<std::string>(name, {size, utils::constraints::PrimaryKey});
} // }
//
template<> // template<>
attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column) { // attribute make_fk_column<std::string>(const std::string &name, size_t size, const std::shared_ptr<attribute> &ref_column) {
return { // return {
name, utils::data_type_traits<std::string>::type(size), 0, ref_column, // name, utils::data_type_traits<std::string>::type(size), 0, ref_column,
{size, utils::constraints::ForeignKey}, null_option_type::NOT_NULL // {size, utils::constraints::ForeignKey}, null_option_type::NOT_NULL
}; // };
} // }
//
template<> // template<>
attribute make_fk_column<std::string>( const std::string& name, const std::string& ref_table_name, const std::string& ref_column_name ) { // attribute make_fk_column<std::string>( const std::string& name, const std::string& ref_table_name, const std::string& ref_column_name ) {
return { // return {
name, utils::basic_type::type_varchar, 0, // name, utils::basic_type::type_varchar, 0,
std::make_shared<attribute>(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::ForeignKey}), // std::make_shared<attribute>(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::ForeignKey}),
{ 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL // { 0, utils::constraints::ForeignKey }, null_option_type::NOT_NULL
}; // };
} // }
//
template<> // template<>
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) { // 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) {
const auto ref_column = std::make_shared<attribute>(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::ForeignKey}); // const auto ref_column = std::make_shared<attribute>(ref_column_name, utils::basic_type::type_varchar, ref_table_name, attribute_options{utils::constraints::ForeignKey});
return { // return {
name, utils::data_type_traits<std::string>::type(size), 0, ref_column, // name, utils::data_type_traits<std::string>::type(size), 0, ref_column,
{size, utils::constraints::ForeignKey}, null_option_type::NOT_NULL // {size, utils::constraints::ForeignKey}, null_option_type::NOT_NULL
}; // };
} // }
} }

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

@ -1,5 +1,6 @@
#include "matador/object/attribute_generator.hpp" #include "matador/object/attribute_generator.hpp"
#include "matador/object/repository.hpp" #include "matador/object/repository.hpp"
#include "matador/object/object.hpp"
namespace matador::object { namespace matador::object {
@ -13,12 +14,16 @@ void attribute_generator::on_revision(const char *id, uint64_t &rev) {
on_attribute(id, rev); on_attribute(id, rev);
} }
utils::result<std::shared_ptr<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 {
return repo_.reference_column(ti); return repo_.primary_key_attribute(ti);
} }
void attribute_generator::insert_missing_reference_column(const std::type_index& ti, const std::shared_ptr<attribute>& ref_column) const { void attribute_generator::insert_missing_reference_column(const std::type_index& ti, attribute* ref_column) const {
const_cast<repository&>(repo_).missing_references_.insert({ti, ref_column}); const_cast<repository&>(repo_).missing_references_.insert({ti, ref_column});
} }
void attribute_generator::prepare_primary_key(attribute& ref, utils::identifier &&pk) const {
obj_.pk_attribute_ = &ref;
obj_.pk_identifier_ = std::move(pk);
}
} }

46
source/core/object/basic_object_info.cpp
View File

@ -5,20 +5,24 @@
#include <algorithm> #include <algorithm>
namespace matador::object { namespace matador::object {
basic_object_info::basic_object_info(std::shared_ptr<repository_node> node, // basic_object_info::basic_object_info(std::shared_ptr<repository_node> node,
const std::vector<attribute> &attributes, // const std::vector<attribute> &attributes,
utils::identifier &&pk, // utils::identifier &&pk,
const std::shared_ptr<attribute> &pk_as_fk_column) // const std::shared_ptr<attribute> &pk_as_fk_column)
: node_(std::move(node)) // : node_(std::move(node))
, attributes_(attributes) // , attributes_(attributes)
, identifier_(std::move(pk)) // , identifier_(std::move(pk))
, pk_as_fk_column_(pk_as_fk_column) { // , pk_as_fk_column_(pk_as_fk_column) {
} // }
//
// basic_object_info::basic_object_info(std::shared_ptr<repository_node> node,
// const std::vector<attribute> &attributes)
// : node_(std::move(node))
// , attributes_(attributes) {}
basic_object_info::basic_object_info(std::shared_ptr<repository_node> node, basic_object_info::basic_object_info(std::shared_ptr<repository_node> node, std::unique_ptr<object>&& obj)
const std::vector<attribute> &attributes) : object_(std::move(obj))
: node_(std::move(node)) , node_(std::move(node)) {}
, attributes_(attributes) {}
std::type_index basic_object_info::type_index() const { std::type_index basic_object_info::type_index() const {
return node_->type_index(); return node_->type_index();
@ -29,19 +33,23 @@ std::string basic_object_info::name() const {
} }
const std::vector<attribute>& basic_object_info::attributes() const { const std::vector<attribute>& basic_object_info::attributes() const {
return attributes_; return object_->attributes();
} }
std::shared_ptr<attribute> basic_object_info::reference_column() const { // std::shared_ptr<attribute> basic_object_info::reference_column() const {
return pk_as_fk_column_; // return pk_as_fk_column_;
} // }
bool basic_object_info::has_primary_key() const { bool basic_object_info::has_primary_key() const {
return identifier_.has_value(); return object_->has_primary_key();
} }
const utils::identifier& basic_object_info::primary_key() const { const utils::identifier& basic_object_info::primary_key() const {
return identifier_.value(); return object_->primary_key();
}
attribute* basic_object_info::primary_key_attribute() const {
return object_->primary_key_attribute();
} }
basic_object_info::endpoint_iterator basic_object_info::register_relation_endpoint(const std::type_index &type, const std::shared_ptr<relation_endpoint> &endpoint) { basic_object_info::endpoint_iterator basic_object_info::register_relation_endpoint(const std::type_index &type, const std::shared_ptr<relation_endpoint> &endpoint) {

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

@ -19,7 +19,7 @@ void constraints_generator::create_pk_constraint(const std::string& name) const
} }
void constraints_generator::create_fk_constraint(const std::string& name, const basic_object_info& info) const { void constraints_generator::create_fk_constraint(const std::string& name, const basic_object_info& info) const {
const auto pk_attribute = info.reference_column(); const auto *pk_attribute = info.primary_key_attribute();
class constraint pk_constraint("FK_" + obj_.name() + "_" + name); class constraint 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_)) {
@ -27,7 +27,7 @@ void constraints_generator::create_fk_constraint(const std::string& name, const
} }
pk_constraint.owner_ = &obj_; pk_constraint.owner_ = &obj_;
pk_constraint.ref_column_name_ = pk_attribute->name(); pk_constraint.ref_column_name_ = pk_attribute->name();
pk_constraint.ref_table_name_ = pk_attribute->table_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));
} }

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

@ -14,6 +14,8 @@ std::string object_category_impl::message(const int ev) const {
return "Node not found"; return "Node not found";
case error_code::NodeAlreadyExists: case error_code::NodeAlreadyExists:
return "Node already exists"; return "Node already exists";
case error_code::NoPrimaryKey:
return "No primary key";
case error_code::Failure: case error_code::Failure:
return "Failure"; return "Failure";
default: default:

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

@ -21,6 +21,18 @@ void object::add_constraint( class constraint c ) {
ref.owner_ = this; ref.owner_ = this;
} }
attribute* object::primary_key_attribute() const {
return pk_attribute_;
}
const utils::identifier& object::primary_key() const {
return pk_identifier_;
}
bool object::has_primary_key() const {
return pk_attribute_ != nullptr;
}
const std::string& object::name() const { const std::string& object::name() const {
return name_; return name_;
} }
@ -29,6 +41,10 @@ const std::string& object::alias() const {
return alias_; return alias_;
} }
void object::update_name(const std::string& name) {
name_ = name;
}
bool object::has_attributes() const { bool object::has_attributes() const {
return attributes_.empty(); return attributes_.empty();
} }

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

@ -62,13 +62,16 @@ utils::result<basic_object_info_ref, utils::error> repository::basic_info( const
return utils::ok(basic_object_info_ref{result.value()->info()}); return utils::ok(basic_object_info_ref{result.value()->info()});
} }
utils::result<std::shared_ptr<attribute>, utils::error> repository::reference_column(const std::type_index &type_index) const { utils::result<attribute*, utils::error> repository::primary_key_attribute(const std::type_index &type_index) const {
const auto result = find_node(type_index); const auto result = find_node(type_index);
if (result) { if (!result) {
return utils::ok((*result)->info().reference_column()); return utils::failure(result.err());
} }
return utils::failure(result.err()); if (!result.value()->info().has_primary_key()) {
return utils::failure(make_error(error_code::NodeAlreadyExists, "Object '" + result.value()->name() + "' does not have a primary key."));
}
return utils::ok((*result)->info().primary_key_attribute());
} }
void repository::dump(std::ostream &os) const { void repository::dump(std::ostream &os) const {

12
source/core/object/repository_node.cpp
View File

@ -45,9 +45,9 @@ const basic_object_info &repository_node::info() const {
void repository_node::update_name(const std::string& name) { void repository_node::update_name(const std::string& name) {
name_ = name; name_ = name;
if (info_->reference_column()) { // if (info_->reference_column()) {
info_->reference_column()->table_name(name); // info_->reference_column()->table_name(name);
} // }
} }
const repository& repository_node::schema() const { const repository& repository_node::schema() const {
@ -104,19 +104,19 @@ utils::result<repository_node::node_ptr, utils::error> repository_node::make_and
return repo.attach_node(node, ""); return repo.attach_node(node, "");
} }
std::shared_ptr<attribute> repository_node::determine_reference_column(const std::type_index& ti, attribute* repository_node::determine_reference_column(const std::type_index& ti,
const std::string& table_name, const std::string& table_name,
const primary_key_info& pk_info, const primary_key_info& pk_info,
repository& repo) { repository& repo) {
const auto it = repo.missing_references_.find(ti); const auto it = repo.missing_references_.find(ti);
if (it == repo.missing_references_.end()) { if (it == repo.missing_references_.end()) {
return std::make_shared<attribute>(pk_info.pk_column_name, pk_info.type, table_name, attribute_options{utils::constraints::ForeignKey}); return new attribute(pk_info.pk_column_name, pk_info.type, {utils::constraints::ForeignKey}, null_option_type::NOT_NULL);
} }
auto ref_column = it->second; auto ref_column = it->second;
repo.missing_references_.erase(it); repo.missing_references_.erase(it);
ref_column->name(pk_info.pk_column_name); ref_column->name(pk_info.pk_column_name);
ref_column->table_name(table_name); ref_column->owner()->update_name(table_name);
ref_column->change_type(pk_info.type); ref_column->change_type(pk_info.type);
ref_column->attributes() = utils::constraints::ForeignKey; ref_column->attributes() = utils::constraints::ForeignKey;

1
test/core/object/ObjectTest.cpp
View File

@ -17,4 +17,5 @@ TEST_CASE("Generate object from type", "[object][generate]") {
REQUIRE(obj->alias().empty()); REQUIRE(obj->alias().empty());
REQUIRE(obj->attributes().size() == 4); REQUIRE(obj->attributes().size() == 4);
REQUIRE(obj->constraints().size() == 2); REQUIRE(obj->constraints().size() == 2);
REQUIRE(obj->has_primary_key());
} }