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

introduced field_attributes shortcuts and added method on_base() to all processor classes

This commit is contained in:
sascha 2026-04-22 11:03:33 +02:00
parent 78eb5d04cd
commit 9b25f7f556
68 changed files with 248 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backends/postgres/src/postgres_connection.cpp
View File

@ -281,7 +281,7 @@ utils::result<std::vector<object::attribute>, utils::error> postgres_connection:
null_opt = object::null_option_type::NotNull;
}
// f.default_value(res->column(4));
prototype.emplace_back(name, type, utils::NullAttributes, null_opt);
prototype.emplace_back(name, type, NullAttributes, null_opt);
}
return utils::ok(prototype);

11
demo/author.hpp
View File

@ -20,14 +20,15 @@ struct author {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::primary_key( op, "id", id );
field::attribute( op, "first_name", first_name, 63 );
field::attribute( op, "last_name", last_name, 63 );
field::attribute( op, "date_of_birth", date_of_birth, 31 );
field::attribute( op, "first_name", first_name, VarChar63 );
field::attribute( op, "last_name", last_name, VarChar63 );
field::attribute( op, "date_of_birth", date_of_birth, VarChar63 );
field::attribute( op, "year_of_birth", year_of_birth );
field::attribute( op, "distinguished", distinguished );
field::has_many( op, "books", books, "author_id", matador::utils::CascadeNoneFetchLazy );
field::has_many( op, "books", books, "author_id", utils::CascadeNoneFetchLazy );
}
};
}

7
demo/book.hpp
View File

@ -15,10 +15,11 @@ struct book {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::primary_key( op, "id", id );
field::attribute( op, "title", title, 511 );
field::belongs_to( op, "author_id", book_author, matador::utils::CascadeNoneFetchLazy );
field::attribute( op, "title", title, VarChar511 );
field::belongs_to( op, "author_id", book_author, utils::CascadeNoneFetchLazy );
field::attribute( op, "published_in", published_in );
}
};

2
demo/object.cpp
View File

@ -29,7 +29,7 @@ public:
attribute() = default;
attribute(std::string name,
utils::basic_type type,
const utils::field_attributes& opts = utils::NullAttributes,
const utils::field_attributes& opts = matador::NullAttributes,
null_option_type null_opt = null_option_type::NotNull)
: name_(std::move(name)), type_(type), options_(opts), null_option_type_(null_opt) {}

20
demo/recipe.hpp
View File

@ -13,8 +13,7 @@
namespace demo {
struct recipe;
struct ingredient
{
struct ingredient {
unsigned int id{};
std::string name;
matador::object::collection<matador::object::object_ptr<demo::recipe>> recipes{};
@ -25,15 +24,15 @@ struct ingredient
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::has_many_to_many(op, "recipe_ingredients", recipes, "ingredient_id", "recipe_id", matador::utils::fetch_type::Eager);
field::attribute(op, "name", name, VarChar255);
field::has_many_to_many(op, "recipe_ingredients", recipes, "ingredient_id", "recipe_id", utils::CascadeAllFetchEager);
}
};
struct recipe
{
struct recipe {
unsigned int id{};
std::string name;
matador::object::collection<matador::object::object_ptr<demo::ingredient>> ingredients{};
@ -44,10 +43,11 @@ struct recipe
template<class Operator>
void process(Operator &op) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::has_many_to_many(op, "recipe_ingredients", ingredients, matador::utils::fetch_type::Lazy);
field::attribute(op, "name", name, VarChar255);
field::has_many_to_many(op, "recipe_ingredients", ingredients, utils::CascadeAllFetchLazy);
}
};

19
demo/sandbox.cpp
View File

@ -81,11 +81,12 @@ struct profile {
template<typename Operator>
void process(Operator &op) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::primary_key( op, "id", id );
field::attribute( op, "first_name", first_name, 255 );
field::attribute( op, "last_name", last_name, 255 );
field::belongs_to( op, "user_id", user, matador::utils::CascadeNoneFetchLazy );
field::attribute( op, "first_name", first_name, VarChar255 );
field::attribute( op, "last_name", last_name, VarChar255 );
field::belongs_to( op, "user_id", user, utils::CascadeNoneFetchLazy );
}
};
struct user {
@ -95,10 +96,11 @@ struct user {
template<typename Operator>
void process(Operator &op) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::primary_key( op, "id", id );
field::attribute( op, "username", username, 255 );
field::has_one(op, "profile_id", profile, matador::utils::CascadeNoneFetchLazy );
field::attribute( op, "username", username, VarChar255 );
field::has_one(op, "profile_id", profile, utils::CascadeNoneFetchLazy );
}
};
@ -108,9 +110,10 @@ struct person {
template<typename Operator>
void process(Operator &op) {
using namespace matador;
namespace field = matador::access;
field::primary_key( op, "id", id );
field::attribute( op, "name", name, 255 );
field::attribute( op, "name", name, VarChar255 );
}
};

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

@ -36,12 +36,13 @@ struct CollectionCenter : core::Model {
template<typename Operator>
void process( Operator& op ) {
using namespace matador;
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "name", name, UniqueVarChar511 );
field::attribute( op, "symbol", symbol );
field::attribute( op, "type", type );
field::has_many( op, "collection_center_users", users, "users_id", matador::utils::fetch_type::Lazy );
field::has_many( op, "collection_center_users", users, "users_id", utils::CascadeAllFetchLazy );
}
};

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

@ -15,4 +15,4 @@ struct InternalUserDirectory : UserDirectory {
};
}
#endif //INTERNALUSERDIRECTORY_HPP
#endif //INTERNAL_USER_DIRECTORY_HPP

9
demo/work/admin/LdapGroupSchemaSettings.hpp
View File

@ -16,11 +16,12 @@ struct LdapGroupSchemaSettings : core::Model {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::process( op, *matador::base_class<Model>( this ) );
field::has_one(op, "ldap_user_directory", ldap_user_directory, matador::utils::CascadeAllFetchLazy);
field::attribute( op, "group_object_filter", group_object_filter, 511 );
field::attribute( op, "user_member_attribute", user_member_attribute, 511 );
field::has_one(op, "ldap_user_directory", ldap_user_directory, utils::CascadeAllFetchLazy);
field::attribute( op, "group_object_filter", group_object_filter, VarChar511 );
field::attribute( op, "user_member_attribute", user_member_attribute, VarChar511 );
}
};

7
demo/work/admin/LdapImportSettings.hpp
View File

@ -17,10 +17,11 @@ struct LdapImportSettings : core::Model {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::process( op, *matador::base_class<Model>( this ) );
field::has_one(op, "ldap_user_directory", ldap_user_directory, matador::utils::CascadeAllFetchLazy);
field::attribute( op, "default_role", default_role, 511 );
field::has_one(op, "ldap_user_directory", ldap_user_directory, utils::CascadeAllFetchLazy);
field::attribute( op, "default_role", default_role, VarChar511 );
field::attribute( op, "sync_interval", sync_interval );
field::attribute( op, "network_timeout", network_timeout );
}

19
demo/work/admin/LdapUserDirectory.hpp
View File

@ -25,16 +25,17 @@ struct LdapUserDirectory : UserDirectory {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::process( op, *matador::base_class<UserDirectory>( this ) );
field::attribute( op, "schema_base_dn", schema_base_dn, 511 );
field::attribute( op, "additional_user_base_dn", additional_user_base_dn, 511 );
field::attribute( op, "additional_group_base_dn", additional_group_base_dn, 511 );
field::belongs_to( op, "user_schema_settings", user_schema_settings, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "group_schema_settings", group_schema_settings, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "import_settings", import_settings, matador::utils::CascadeAllFetchLazy );
field::has_many( op, "ldap_users", users, "users_id", matador::utils::CascadeAllFetchEager );
field::has_many( op, "ldap_groups", groups, "groups_id", matador::utils::CascadeAllFetchEager );
field::attribute( op, "schema_base_dn", schema_base_dn, VarChar511 );
field::attribute( op, "additional_user_base_dn", additional_user_base_dn, VarChar511 );
field::attribute( op, "additional_group_base_dn", additional_group_base_dn, VarChar511 );
field::belongs_to( op, "user_schema_settings", user_schema_settings, utils::CascadeAllFetchLazy );
field::belongs_to( op, "group_schema_settings", group_schema_settings, utils::CascadeAllFetchLazy );
field::belongs_to( op, "import_settings", import_settings, utils::CascadeAllFetchLazy );
field::has_many( op, "ldap_users", users, "users_id", utils::CascadeAllFetchEager );
field::has_many( op, "ldap_groups", groups, "groups_id", utils::CascadeAllFetchEager );
}
};
}

13
demo/work/admin/LdapUserSchemaSettings.hpp
View File

@ -18,13 +18,14 @@ struct LdapUserSchemaSettings : core::Model {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::process(op, *matador::base_class<Model>( this ));
field::has_one(op, "ldap_user_directory", ldap_user_directory, matador::utils::CascadeAllFetchLazy);
field::attribute(op, "user_object_filter", user_object_filter, 511);
field::attribute(op, "user_unique_id_attribute", user_unique_id_attribute, 511);
field::attribute(op, "user_member_of_attribute", user_member_of_attribute, 511);
field::attribute(op, "user_name_attribute", user_name_attribute, 511);
field::has_one(op, "ldap_user_directory", ldap_user_directory, utils::CascadeAllFetchLazy);
field::attribute(op, "user_object_filter", user_object_filter, VarChar511);
field::attribute(op, "user_unique_id_attribute", user_unique_id_attribute, VarChar511);
field::attribute(op, "user_member_of_attribute", user_member_of_attribute, VarChar511);
field::attribute(op, "user_name_attribute", user_name_attribute, VarChar511);
}
};

11
demo/work/admin/LoginHistory.hpp
View File

@ -51,13 +51,14 @@ struct LoginHistory : core::Model {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::process_base<Model>( op, *this );
field::process( op, *matador::base_class<Model>( this ) );
field::belongs_to( op, "client", client, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "scenario", scenario, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "collection_center", collection_center, matador::utils::CascadeAllFetchLazy );
field::attribute( op, "login_name", login_name, 511 );
field::belongs_to( op, "client", client, utils::CascadeAllFetchLazy );
field::belongs_to( op, "scenario", scenario, utils::CascadeAllFetchLazy );
field::belongs_to( op, "collection_center", collection_center, utils::CascadeAllFetchLazy );
field::attribute( op, "login_name", login_name, VarChar511 );
field::attribute( op, "fail_reason", fail_reason );
field::attribute( op, "login_time", login_time );
}

9
demo/work/admin/Scenario.hpp
View File

@ -46,14 +46,15 @@ struct Scenario : core::Model {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "name", name, UniqueVarChar511 );
field::attribute( op, "mode", mode );
field::attribute( op, "description", description, 511 );
field::attribute( op, "description", description, VarChar511 );
field::attribute( op, "symbol", symbol );
field::attribute( op, "state", state );
field::has_many( op, "collection_center", collection_center, "scenario_id", matador::utils::fetch_type::Lazy );
field::has_many( op, "collection_center", collection_center, "scenario_id", utils::CascadeAllFetchLazy );
}
};
}

15
demo/work/admin/User.hpp
View File

@ -29,17 +29,18 @@ struct User : core::Model {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "name", name, UniqueVarChar511 );
field::attribute( op, "symbol", symbol );
field::attribute( op, "salt", salt, 511 );
field::attribute( op, "password", password, 511 );
field::attribute( op, "salt", salt, VarChar511 );
field::attribute( op, "password", password, VarChar511 );
field::attribute( op, "lock_type", lock_type );
field::attribute( op, "locked_at", locked_at );
field::attribute( op, "lock_reason", lock_reason, 511 );
field::attribute( op, "role", role, 63 );
field::belongs_to( op, "user_directory", user_directory, matador::utils::CascadeAllFetchLazy );
field::attribute( op, "lock_reason", lock_reason, VarChar511 );
field::attribute( op, "role", role, VarChar63 );
field::belongs_to( op, "user_directory", user_directory, utils::CascadeAllFetchLazy );
}
};

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

@ -13,7 +13,7 @@ struct UserDirectory : core::Model {
void process( Operator& op ) {
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "name", name, matador::VarChar511 );
}
};
}

9
demo/work/admin/UserSession.hpp
View File

@ -21,11 +21,12 @@ struct UserSession : core::Model {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
namespace field = access;
field::process( op, *matador::base_class<Model>( this ) );
field::belongs_to( op, "client", client, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "scenario", scenario, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "collection_center", collection_center, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "client", client, utils::CascadeAllFetchLazy );
field::belongs_to( op, "scenario", scenario, utils::CascadeAllFetchLazy );
field::belongs_to( op, "collection_center", collection_center, utils::CascadeAllFetchLazy );
field::attribute( op, "offline_since", offline_since );
}
};

6
demo/work/core/UserInfo.hpp
View File

@ -2,6 +2,7 @@
#define USERINFO_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
namespace work::core {
struct UserInfo {
@ -12,9 +13,10 @@ struct UserInfo {
template<typename Operator>
void process( Operator& op ) {
namespace field = matador::access;
using namespace matador;
field::attribute( op, "user_session_id", user_session_id );
field::attribute( op, "user_role", user_role, 255 );
field::attribute( op, "database_name", database_name, 255 );
field::attribute( op, "user_role", user_role, VarChar255 );
field::attribute( op, "database_name", database_name, VarChar255 );
}
};
}

9
demo/work/jobs/Job.hpp
View File

@ -30,15 +30,16 @@ struct Job : core::Model {
template<typename Operator>
void process( Operator& op ) {
using namespace matador;
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "description", description, 511 );
field::attribute( op, "name", name, UniqueVarChar511 );
field::attribute( op, "description", description, VarChar1023 );
field::attribute( op, "state", state );
field::attribute( op, "mode", mode );
field::attribute( op, "created_at", created_at );
field::has_one(op, "payload", payload, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "task", task, matador::utils::CascadeAllFetchLazy );
field::has_one(op, "payload", payload, utils::CascadeAllFetchLazy );
field::belongs_to( op, "task", task, utils::CascadeAllFetchLazy );
field::attribute( op, "user_info", user_info );
}
};

5
demo/work/jobs/Payload.hpp
View File

@ -16,10 +16,11 @@ struct Payload : core::Model {
template<typename Operator>
void process( Operator& op ) {
using namespace matador;
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "type", type, 255 );
field::belongs_to( op, "job", job, matador::utils::CascadeAllFetchLazy );
field::attribute( op, "type", type, VarChar255 );
field::belongs_to( op, "job", job, utils::CascadeAllFetchLazy );
}
};
}

9
demo/work/jobs/Task.hpp
View File

@ -26,13 +26,14 @@ struct Task : core::Model {
template<typename Operator>
void process( Operator& op ) {
using namespace matador;
namespace field = matador::access;
field::process( op, *matador::base_class<Model>( this ) );
field::attribute( op, "name", name, 511 );
field::attribute( op, "description", description, 511 );
field::attribute( op, "job_name", job_name, 511 );
field::attribute( op, "name", name, UniqueVarChar511 );
field::attribute( op, "description", description, VarChar1023 );
field::attribute( op, "job_name", job_name, VarChar511 );
field::attribute( op, "state", state );
field::belongs_to( op, "payload", payload, matador::utils::CascadeAllFetchLazy );
field::belongs_to( op, "payload", payload, utils::CascadeAllFetchLazy );
field::attribute( op, "job_mode", job_mode );
field::attribute( op, "start_delay", start_delay );
field::attribute( op, "interval", interval );

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

@ -28,7 +28,7 @@ public:
attribute() = default;
attribute(std::string name,
utils::basic_type type,
const utils::field_attributes &attr = utils::NullAttributes,
const utils::field_attributes &attr = NullAttributes,
null_option_type null_opt = null_option_type::NotNull);
[[nodiscard]] const std::string& name() const;
@ -39,9 +39,9 @@ public:
[[nodiscard]] bool is_nullable() const;
[[nodiscard]] utils::basic_type type() const;
[[nodiscard]] std::shared_ptr<object> owner() const;
void change_type(utils::basic_type type, const utils::field_attributes &attr = utils::NullAttributes);
void change_type(utils::basic_type type, const utils::field_attributes &attr = NullAttributes);
template < typename Type >
void change_type(const utils::field_attributes &attr = utils::NullAttributes) {
void change_type(const utils::field_attributes &attr = NullAttributes) {
type_ = utils::data_type_traits<Type>::type(attr.size());
}

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

@ -38,6 +38,8 @@ public:
completer.complete_node(node);
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<class PrimaryKeyType>
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute & /*attr*/) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}

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

@ -24,6 +24,8 @@ public:
return join_columns_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class V >
static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}

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

@ -74,6 +74,8 @@ public:
return obj;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class Type >
void on_primary_key(const char *, Type &x, const utils::primary_key_attribute& attr);
void on_revision(const char *id, uint64_t &rev);

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

@ -34,6 +34,8 @@ struct pk_field_locator {
explicit pk_field_locator (Type &obj)
: base(&obj) {}
template<typename BaseType>
static void on_base(const BaseType&) {}
template <typename PrimaryKeyType>
void on_primary_key(const char *, PrimaryKeyType &pk, const utils::primary_key_attribute & /*attr*/) {
// Offset bestimmen

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

@ -43,6 +43,8 @@ public:
return resolver.resolve(obj);
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class Type >
void on_primary_key(const char *id, Type &pk, const utils::primary_key_attribute& attr) {
primary_key_info_.pk_column_name = id;

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

@ -28,6 +28,8 @@ public:
return finder.found_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<class PrimaryKeyType>
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
@ -102,6 +104,8 @@ public:
completer.complete_node_relations(node);
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<class PrimaryKeyType>
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}

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

@ -165,6 +165,8 @@ public:
return stmt_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<class Type>
void on_primary_key(const char * /*id*/, Type &x, const utils::primary_key_attribute & /*attr*/) {
stmt_.bind(binding_position_, x);

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

@ -40,6 +40,8 @@ public:
return generator_type_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<class V>
void on_primary_key(const char * /*id*/, V &/*pk*/, const utils::primary_key_attribute &attr) {
generator_type_ = attr.generator();

2
include/matador/query/dependency_collector.hpp
View File

@ -59,6 +59,8 @@ struct meta_registry {
struct dependency_collector {
std::vector<fk_ref> refs;
template<typename BaseType>
static void on_base(const BaseType&) {}
template<class V>
static void on_primary_key(const char*, V&, const utils::primary_key_attribute& /*attr*/) {}

2
include/matador/query/fk_value_extractor.hpp
View File

@ -24,6 +24,8 @@ public:
return value_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
void on_primary_key(const char *, ValueType &pk, const utils::primary_key_attribute& /*attr*/) {
value_ = pk;

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

@ -63,6 +63,8 @@ public:
return result_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class V >
void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/) {
push(id);
@ -169,6 +171,8 @@ public:
return result_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class V >
void on_primary_key(const char * /*id*/, V &/*x*/, const utils::primary_key_attribute& /*attr*/) {
result_.emplace_back(utils::_);
@ -227,6 +231,8 @@ public:
return std::move(result_);
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class V >
void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/) {
push_back(id, x);

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

@ -23,6 +23,8 @@ class has_many_linker {
public:
has_many_linker(const object::object_ptr<ObjectType> &ptr, std::string join_column)
: ptr_(ptr), join_column_(std::move(join_column)) {}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class PrimaryKeyType >
static void on_primary_key(const char * /*id*/, PrimaryKeyType &, const utils::primary_key_attribute& /*attr*/) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}

2
include/matador/query/key_value_generator.hpp
View File

@ -26,6 +26,8 @@ public:
return result;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class V >
void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/) {
result_.emplace_back(id, x);

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

@ -60,6 +60,8 @@ public:
, root_type_(root_type)
{}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
static void on_primary_key(const char * /*id*/, ValueType &/*value*/, const utils::primary_key_attribute& /*attr*/) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}

3
include/matador/query/select_query_builder.hpp
View File

@ -89,6 +89,9 @@ public:
}
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class V >
void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/) {
push(id);

2
include/matador/query/value_extractor.hpp
View File

@ -25,6 +25,8 @@ public:
return values;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
void on_primary_key(const char *, ValueType &x, const utils::primary_key_attribute& attr) {
utils::data_type_traits<ValueType>::bind_value(*this, 0, x, attr.size());

2
include/matador/sql/generator.hpp
View File

@ -44,6 +44,8 @@ public:
return columns;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class V >
void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/) {
if (has_many_to_many_) {

2
include/matador/sql/internal/identifier_reader.hpp
View File

@ -22,6 +22,8 @@ public:
return identifier_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr) {
utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_, value, attr.size());

4
include/matador/sql/internal/object_result_binder.hpp
View File

@ -27,6 +27,8 @@ public:
binder_ = nullptr;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr);
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
@ -73,6 +75,8 @@ public:
void reset();
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class Type >
void on_primary_key(const char *id, Type &val, const utils::primary_key_attribute& attr) {
utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val, attr.size());

2
include/matador/sql/internal/pk_reader.hpp
View File

@ -14,6 +14,8 @@ public:
access::process(*this, obj);
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr);
void on_revision(const char * /*id*/, uint64_t &/*rev*/) {

2
include/matador/sql/internal/query_result_impl.hpp
View File

@ -40,6 +40,8 @@ public:
const std::type_index& result_type,
size_t column_index = 0);
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr) {
utils::data_type_traits<ValueType>::read_value(*reader_, id, column_index_++, value, attr.size());

2
include/matador/sql/internal/query_result_pk_resolver.hpp
View File

@ -27,6 +27,8 @@ public:
return pk_;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &/*value*/, const utils::primary_key_attribute& attr) {
if (!type_stack_.empty()) {

2
include/matador/sql/object_parameter_binder.hpp
View File

@ -17,6 +17,8 @@ public:
void reset(size_t start_index);
[[nodiscard]] size_t current_index() const;
template<typename BaseType>
static void on_base(const BaseType&) {}
template < class Type >
void on_primary_key(const char * /*id*/, Type &val, const utils::primary_key_attribute& attr) {
utils::data_type_traits<Type>::bind_value(*binder_, index_++, val, attr.size());

2
include/matador/sql/object_pk_binder.hpp
View File

@ -19,6 +19,8 @@ public:
binder_ = nullptr;
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr);
static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}

4
include/matador/utils/access.hpp
View File

@ -53,12 +53,12 @@ void revision(Operator &op, const char *id, uint64_t &value) {
}
template<class Operator, class Type>
void attribute(Operator &op, const char *id, Type &value, const utils::field_attributes &attr = utils::NullAttributes) {
void attribute(Operator &op, const char *id, Type &value, const utils::field_attributes &attr = NullAttributes) {
op.on_attribute(id, value, attr);
}
template<class Operator, class Type>
void attribute(Operator &op, const char *id, std::optional<Type> &value, const utils::field_attributes &attr = utils::NullAttributes) {
void attribute(Operator &op, const char *id, std::optional<Type> &value, const utils::field_attributes &attr = NullAttributes) {
op.on_attribute(id, value, attr);
}

29
include/matador/utils/field_attributes.hpp
View File

@ -73,8 +73,31 @@ private:
size_t size_ = 0;
constraints options_ = constraints::None;
};
const field_attributes NullAttributes {};
}
namespace matador {
const utils::field_attributes NullAttributes {};
const utils::field_attributes VarChar63 {63};
const utils::field_attributes VarChar127 {127};
const utils::field_attributes VarChar255 {255};
const utils::field_attributes VarChar511 {511};
const utils::field_attributes VarChar1023 {1023};
const utils::field_attributes VarChar2047 {2047};
const utils::field_attributes VarChar4095 {4095};
const utils::field_attributes UniqueVarChar63 {63, utils::constraints::Unique};
const utils::field_attributes UniqueVarChar127 {127, utils::constraints::Unique};
const utils::field_attributes UniqueVarChar255 {255, utils::constraints::Unique};
const utils::field_attributes UniqueVarChar511 {511, utils::constraints::Unique};
const utils::field_attributes UniqueVarChar1023 {1023, utils::constraints::Unique};
const utils::field_attributes UniqueVarChar2047 {2047, utils::constraints::Unique};
const utils::field_attributes UniqueVarChar4095 {4095, utils::constraints::Unique};
const utils::field_attributes PrimaryKeyVarChar63 {63, utils::constraints::PrimaryKey};
const utils::field_attributes PrimaryKeyVarChar127 {127, utils::constraints::PrimaryKey};
const utils::field_attributes PrimaryKeyVarChar255 {255, utils::constraints::PrimaryKey};
const utils::field_attributes PrimaryKeyVarChar511 {511, utils::constraints::PrimaryKey};
const utils::field_attributes PrimaryKeyVarChar1023 {1023, utils::constraints::PrimaryKey};
const utils::field_attributes PrimaryKeyVarChar2047 {2047, utils::constraints::PrimaryKey};
const utils::field_attributes PrimaryKeyVarChar4095 {4095, utils::constraints::PrimaryKey};
}
#endif //MATADOR_FIELD_ATTRIBUTES_HPP

6
include/matador/utils/primary_key_accessor.hpp
View File

@ -21,6 +21,8 @@ public:
access::process(*this, obj);
}
template<typename BaseType>
static void on_base(const BaseType&) {}
template<typename PrimaryKeyType>
void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = DefaultPkAttributes) {
const auto value = pk_.as<PrimaryKeyType>();
@ -51,6 +53,8 @@ private:
struct pk_unset_checker {
bool unset{true};
template<typename BaseType>
static void on_base(const BaseType&) {}
template<class PrimaryKeyType>
void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = DefaultPkAttributes) {
unset = !identifier_type_traits<PrimaryKeyType>::is_valid(pk);
@ -73,6 +77,8 @@ struct pk_unset_checker {
struct primary_key_getter {
std::uint64_t value{0};
template<typename BaseType>
static void on_base(const BaseType&) {}
template<class PrimaryKeyType>
void on_primary_key(const char * /*id*/, PrimaryKeyType &pk, const primary_key_attribute & = DefaultPkAttributes) {
pk_ = pk;

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

@ -48,6 +48,13 @@ private:
};
const primary_key_attribute DefaultPkAttributes {};
const primary_key_attribute ManualVarChar63 {63};
const primary_key_attribute ManualVarChar127 {127};
const primary_key_attribute ManualVarChar255 {255};
const primary_key_attribute ManualVarChar511 {511};
const primary_key_attribute ManualVarChar1023 {1023};
const primary_key_attribute ManualVarChar2047 {2047};
const primary_key_attribute ManualVarChar4095 {4095};
}
#endif //PRIMARY_KEY_ATTRIBUTE_HPP

7
test/backends/QueryBasicTest.cpp
View File

@ -281,7 +281,7 @@ TEST_CASE_METHOD(QueryFixture, "Test describe table", "[query][describe][table]"
"val_char", "val_float", "val_double", "val_short",
"val_int", "val_long_long", "val_unsigned_char",
"val_unsigned_short", "val_unsigned_int", "val_unsigned_long_long",
"val_bool", /*"val_cstr", */"val_string", "val_varchar",
"val_bool", "val_string", "val_varchar",
// "val_date", "val_time",
"val_binary"};
const std::vector<std::function<bool (const attribute&)>> type_check = {
@ -295,11 +295,8 @@ TEST_CASE_METHOD(QueryFixture, "Test describe table", "[query][describe][table]"
[](const attribute &cf) { return cf.is_integer(); },
[](const attribute &cf) { return cf.is_integer(); },
[](const attribute &cf) { return cf.is_integer(); },
// [](const attribute_definition &cf) { return cf.is_integer(); },
// [](const attribute_definition &cf) { return cf.is_integer(); },
[](const attribute &cf) { return cf.is_integer(); },
[](const attribute &cf) { return cf.is_bool(); },
// [](const attribute_definition &cf) { return cf.is_varchar(); },
[](const attribute &cf) { return cf.is_string(); },
[](const attribute &cf) { return cf.is_varchar(); },
// [](const attribute_definition &cf) { return cf.is_date(); },
@ -329,7 +326,7 @@ struct pk {
template<class Operator>
void process(Operator &op) {
access::primary_key(op, "id", id);
access::attribute(op, "name", name, 255);
access::attribute(op, "name", name, VarChar255);
}
uint32_t id{};

8
test/models/airplane.hpp
View File

@ -24,8 +24,8 @@ struct airplane {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "id", id);
field::attribute(op, "brand", brand, 255);
field::attribute(op, "model", model, 255);
field::attribute(op, "brand", brand, UniqueVarChar255);
field::attribute(op, "model", model, UniqueVarChar255);
}
};
}
@ -36,8 +36,8 @@ struct airplane {
// namespace field = matador::access;
// using namespace matador::utils;
// field::primary_key(op, "id", object.id);
// field::attribute(op, "brand", object.brand, 255);
// field::attribute(op, "model", object.model, 255);
// field::attribute(op, "brand", object.brand, UniqueVarChar255);
// field::attribute(op, "model", object.model, UniqueVarChar255);
// }
// template<class Operator>
// void process(Operator &op, const matador::test::airplane &object) {

7
test/models/author.hpp
View File

@ -2,6 +2,7 @@
#define QUERY_AUTHOR_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/object/collection.hpp"
@ -32,9 +33,9 @@ struct author {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "first_name", first_name, 63);
field::attribute(op, "last_name", last_name, 63);
field::attribute(op, "date_of_birth", date_of_birth, 31);
field::attribute(op, "first_name", first_name, VarChar63);
field::attribute(op, "last_name", last_name, VarChar63);
field::attribute(op, "date_of_birth", date_of_birth, VarChar63);
field::attribute(op, "year_of_birth", year_of_birth);
field::attribute(op, "distinguished", distinguished);
field::has_many(op, "books", books, "author_id", utils::CascadeAllFetchLazy);

5
test/models/book.hpp
View File

@ -4,6 +4,7 @@
#include "matador/object/object_ptr.hpp"
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include <string>
@ -13,7 +14,7 @@ struct author;
struct book {
book() = default;
book(const unsigned int id, std::string title, object::object_ptr<author> author, unsigned short published_in)
book(const unsigned int id, std::string title, object::object_ptr<author> author, const unsigned short published_in)
: id(id), title(std::move(title)), book_author(std::move(author)), published_in(published_in) {}
unsigned int id{};
std::string title;
@ -24,7 +25,7 @@ struct book {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "title", title, 511);
field::attribute(op, "title", title, VarChar511);
field::belongs_to(op, "author_id", book_author, utils::CascadeAllFetchEager);
field::attribute(op, "published_in", published_in);
}

3
test/models/category.hpp
View File

@ -2,6 +2,7 @@
#define QUERY_CATEGORY_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include <string>
@ -15,7 +16,7 @@ struct category {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "name", name, UniqueVarChar255);
}
};
}

2
test/models/coordinate.hpp
View File

@ -14,7 +14,7 @@ struct coordinate {
namespace matador::access {
template<class Operator>
void attribute(Operator &op, const char *id, test::coordinate &value, const utils::field_attributes &attr = utils::NullAttributes) {
void attribute(Operator &op, const char *id, test::coordinate &value, const utils::field_attributes &attr = NullAttributes) {
attribute(op, (std::string(id) + "_x").c_str(), value.x, attr);
attribute(op, (std::string(id) + "_y").c_str(), value.y, attr);
attribute(op, (std::string(id) + "_z").c_str(), value.z, attr);

6
test/models/department.hpp
View File

@ -24,7 +24,7 @@ struct department {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 63);
field::attribute(op, "name", name, UniqueVarChar63);
field::has_many(op, "employees", employees, "dep_id", utils::CascadeAllFetchEager);
// field::belongs_to(op, "manager_id", manager, utils::fetch_type::EAGER);
}
@ -43,8 +43,8 @@ struct employee {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "first_name", first_name, 63);
field::attribute(op, "last_name", last_name, 63);
field::attribute(op, "first_name", first_name, VarChar63);
field::attribute(op, "last_name", last_name, VarChar63);
field::belongs_to(op, "dep_id", dep, utils::CascadeAllFetchLazy);
}
};

2
test/models/flight.hpp
View File

@ -30,7 +30,7 @@ struct flight {
using namespace matador::utils;
field::primary_key(op, "id", id);
field::belongs_to(op, "airplane_id", plane, {utils::cascade_type::All, fetch_type::Eager});
field::attribute(op, "pilot_name", pilot_name, 255);
field::attribute(op, "pilot_name", pilot_name, VarChar255);
}
};
}

2
test/models/location.hpp
View File

@ -22,7 +22,7 @@ struct location {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "name", name, UniqueVarChar63);
field::attribute(op, "coordinate", coord);
field::attribute(op, "color", color);
}

2
test/models/optional.hpp
View File

@ -18,7 +18,7 @@ struct optional {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "name", name, VarChar255);
field::attribute(op, "age", age);
}
};

18
test/models/order.hpp
View File

@ -28,17 +28,17 @@ struct order {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "order_id", order_id);
field::attribute(op, "order_date", order_date, 255);
field::attribute(op, "required_date", required_date, 255);
field::attribute(op, "shipped_date", shipped_date, 255);
field::attribute(op, "order_date", order_date, VarChar255);
field::attribute(op, "required_date", required_date, VarChar255);
field::attribute(op, "shipped_date", shipped_date, VarChar255);
field::attribute(op, "ship_via", ship_via);
field::attribute(op, "freight", freight);
field::attribute(op, "ship_name", ship_name, 255);
field::attribute(op, "ship_address", ship_address, 255);
field::attribute(op, "ship_city", ship_city, 255);
field::attribute(op, "ship_region", ship_region, 255);
field::attribute(op, "ship_postal_code", ship_postal_code, 255);
field::attribute(op, "ship_country", ship_country, 255);
field::attribute(op, "ship_name", ship_name, VarChar255);
field::attribute(op, "ship_address", ship_address, VarChar255);
field::attribute(op, "ship_city", ship_city, VarChar255);
field::attribute(op, "ship_region", ship_region, VarChar255);
field::attribute(op, "ship_postal_code", ship_postal_code, VarChar255);
field::attribute(op, "ship_country", ship_country, VarChar255);
field::has_many(op, "order_details", order_details_, "order_id", utils::fetch_type::Eager);
}
};

2
test/models/person.hpp
View File

@ -19,7 +19,7 @@ struct person {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "name", name, UniqueVarChar255);
field::attribute(op, "age", age);
field::attribute(op, "image", image);
}

4
test/models/product.hpp
View File

@ -26,10 +26,10 @@ struct product {
void process(Operator &op) {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "product_name", product_name, 255);
field::primary_key(op, "product_name", product_name, ManualVarChar511);
field::belongs_to(op, "supplier_id", seller, CascadeAllFetchLazy);
field::belongs_to(op, "category_id", type, CascadeAllFetchLazy);
field::attribute(op, "quantity_per_unit", quantity_per_unit, 255);
field::attribute(op, "quantity_per_unit", quantity_per_unit, VarChar255);
field::attribute(op, "unit_price", unit_price);
field::attribute(op, "units_in_stock", units_in_stock);
field::attribute(op, "units_in_order", units_in_order);

9
test/models/recipe.hpp
View File

@ -29,7 +29,7 @@ struct ingredient {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "name", name, UniqueVarChar255);
field::has_many_to_many(op, "recipe_ingredients", recipes, "ingredient_id", "recipe_id", utils::CascadeAllFetchEager);
}
};
@ -53,15 +53,10 @@ struct recipe {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "name", name, UniqueVarChar255);
field::has_many_to_many(op, "recipe_ingredients", ingredients, utils::CascadeAllFetchLazy);
}
};
// class recipe_ingredient : public object::many_to_many_relation<recipe, ingredient> {
// public:
// recipe_ingredient() : many_to_many_relation("recipe_id", "ingredient_id") {}
// };
}
#endif //QUERY_RECIPE_HPP

2
test/models/shipment.hpp
View File

@ -25,7 +25,7 @@ struct shipment {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "tracking_number", tracking_number, 255);
field::attribute(op, "tracking_number", tracking_number, UniqueVarChar255);
field::has_many(op, "packages", packages, "shipment_id", utils::CascadeAllFetchEager);
}
};

12
test/models/student.hpp
View File

@ -2,11 +2,11 @@
#define QUERY_STUDENT_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/object/collection.hpp"
#include "matador/object/many_to_many_relation.hpp"
#include <utility>
#include <vector>
@ -30,7 +30,7 @@ struct student {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "name", name, UniqueVarChar255);
field::has_many_to_many(op, "student_courses", courses, "student_id", "course_id", utils::CascadeAllFetchLazy);
}
};
@ -51,15 +51,9 @@ struct course {
void process(Operator &op) {
namespace field = matador::access;
field::primary_key(op, "id", id);
field::attribute(op, "title", title, 255);
field::attribute(op, "title", title, UniqueVarChar255);
field::has_many_to_many(op, "student_courses", students, utils::CascadeAllFetchEager);
}
};
class student_course : public object::many_to_many_relation<student, course> {
public:
student_course() : many_to_many_relation("student_id", "course_id") {
}
};
}
#endif //QUERY_STUDENT_HPP

2
test/models/supplier.hpp
View File

@ -15,7 +15,7 @@ struct supplier {
namespace field = matador::access;
using namespace matador::utils;
field::primary_key(op, "id", id);
field::attribute(op, "name", name, 255);
field::attribute(op, "name", name, UniqueVarChar255);
}
};
}

6
test/models/types.hpp
View File

@ -6,8 +6,6 @@
namespace matador::test {
struct types {
// enum { CSTR_LEN=255 };
unsigned int id_ = 0;
int8_t char_ = 'c';
short short_ = -127;
@ -20,7 +18,6 @@ struct types {
float float_ = 3.1415f;
double double_ = 1.1414;
bool bool_ = true;
// char cstr_[CSTR_LEN]{};
std::string string_ = "Welt";
std::string varchar_ = "Erde";
// matador::date date_;
@ -43,9 +40,8 @@ struct types {
field::attribute(op, "val_unsigned_int", unsigned_int_);
field::attribute(op, "val_unsigned_long_long", unsigned_long64_);
field::attribute(op, "val_bool", bool_);
// field::attribute(op, "val_cstr", cstr_, CSTR_LEN);
field::attribute(op, "val_string", string_);
field::attribute(op, "val_varchar", varchar_, 63);
field::attribute(op, "val_varchar", varchar_, VarChar63);
// field::attribute(op, "val_date", date_);
// field::attribute(op, "val_time", time_);
field::attribute(op, "val_binary", binary_);