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

changed the interface of on_primary_key to have a third parameter of type primary_key_attribute

This commit is contained in:
Sascha Kühl 2025-07-18 12:08:21 +02:00
parent d8e43c1f95
commit 7b5123df16
38 changed files with 274 additions and 392 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/matador/object/attribute_definition_generator.hpp
View File

@ -7,6 +7,7 @@
#include "matador/utils/data_type_traits.hpp"
#include "matador/utils/error.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include <memory>
@ -29,10 +30,9 @@ public:
}
template<typename ValueType>
void on_primary_key(const char *, ValueType &/*pk*/, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr) {
type_ = utils::data_type_traits<ValueType>::type(0);
void on_primary_key(const char *, ValueType &/*pk*/, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
type_ = utils::data_type_traits<ValueType>::type(attr.size());
}
void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t size);
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
template < class Type >
static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
@ -77,9 +77,8 @@ public:
return columns;
}
template < class V >
void on_primary_key(const char *, V &x, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr);
void on_primary_key(const char *id, std::string &pk, size_t size);
template < class Type >
void on_primary_key(const char *, Type &x, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
void on_revision(const char *id, uint64_t &rev);
template<typename Type>
@ -133,10 +132,9 @@ private:
fk_attribute_generator fk_column_generator_;
};
template<typename V>
void attribute_definition_generator::on_primary_key(const char *id, V &x, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>*)
{
on_attribute(id, x, { utils::constraints::PRIMARY_KEY });
template<typename ValueType>
void attribute_definition_generator::on_primary_key(const char *id, ValueType &x, const utils::primary_key_attribute& attr) {
on_attribute(id, x, { attr.size(), utils::constraints::PRIMARY_KEY });
}
template<typename Type>

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

@ -6,6 +6,8 @@
#include "matador/object/join_columns_collector.hpp"
#include "matador/object/object_ptr.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include "matador/logger/log_manager.hpp"
#include <stack>
@ -33,8 +35,7 @@ public:
}
template<class PrimaryKeyType>
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>> * = nullptr) {}
static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
template<typename AttributeType>
static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}

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

@ -3,6 +3,7 @@
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include <string>
@ -24,8 +25,7 @@ public:
return join_columns_;
}
template < class V >
void on_primary_key(const char * /*id*/, V &, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr) {}
static void on_primary_key(const char * /*id*/, std::string &, size_t) {}
static void on_primary_key(const char * /*id*/, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
template<typename Type>
static void on_attribute(const char * /*id*/, Type &, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}

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

@ -5,6 +5,7 @@
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/identifier.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include <cstdint>
#include <string>
@ -42,14 +43,12 @@ public:
}
template < class Type >
void on_primary_key(const char *id, Type &pk, std::enable_if_t<std::is_integral_v<Type> && !std::is_same_v<bool, Type>>* = nullptr) {
void on_primary_key(const char *id, Type &pk, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
primary_key_info_.pk_column_name = id;
primary_key_info_.type = utils::data_type_traits<Type>::type();
primary_key_info_.type = utils::data_type_traits<Type>::type(attr.size());
primary_key_info_.pk = pk;
}
void on_primary_key(const char *id, const std::string &pk, size_t size);
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
template<typename Type>
static void on_attribute(const char * /*id*/, Type &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}

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

@ -9,6 +9,8 @@
#include "matador/logger/log_manager.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include <iostream>
#include <stack>
#include <utility>
@ -27,8 +29,7 @@ public:
}
template<class PrimaryKeyType>
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>> * = nullptr) {}
static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
template<typename AttributeType>
static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
@ -106,8 +107,7 @@ public:
}
template<class PrimaryKeyType>
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, std::enable_if_t<std::is_integral_v<PrimaryKeyType> && !std::is_same_v<bool, PrimaryKeyType>> * = nullptr) {}
static void on_primary_key(const char * /*id*/, std::string &/*pk*/, size_t /*size*/) {}
static void on_primary_key(const char * /*id*/, PrimaryKeyType &/*pk*/, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {}
static void on_revision(const char * /*id*/, uint64_t &/*rev*/) {}
template<typename AttributeType>
static void on_attribute(const char * /*id*/, AttributeType &/*val*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}

4
include/matador/orm/session_insert_builder.hpp
View File

@ -9,6 +9,7 @@
#include "matador/object/schema.hpp"
#include "matador/utils/cascade_type.hpp"
#include "matador/utils/primary_key_attribute.hpp"
namespace matador::orm {
struct entity_insert_data {
@ -62,11 +63,10 @@ public:
}
template<class V>
void on_primary_key(const char *id, V &x, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>> * = nullptr) {
void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
push(id, x);
}
void on_primary_key(const char *id, std::string &, size_t);
void on_revision(const char *id, unsigned long long &/*rev*/);
template<typename Type>

6
include/matador/orm/session_query_builder.hpp
View File

@ -11,6 +11,7 @@
#include "matador/object/join_columns_collector.hpp"
#include "matador/object/schema.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include "matador/utils/result.hpp"
#include "matador/utils/value.hpp"
@ -76,7 +77,7 @@ public:
}
template < class V >
void on_primary_key(const char *id, V &, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr)
void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes)
{
push(id);
if (!is_root_entity()) {
@ -90,10 +91,11 @@ public:
auto co = std::make_unique<query::condition<sql::column, V>>(c, query::basic_condition::operand_type::EQUAL, v);
entity_query_data_.where_clause = std::move(co);
entity_query_data_.pk_column_name = id;
} else if (pk_.is_varchar()) {
// Todo: handle varchar primary key
}
}
void on_primary_key(const char *id, std::string &, size_t);
void on_revision(const char *id, unsigned long long &/*rev*/);
template<typename Type>

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

@ -4,6 +4,7 @@
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include "matador/utils/types.hpp"
namespace matador::query::detail {
@ -21,26 +22,23 @@ public:
}
template<typename ValueType>
void on_primary_key(const char *, ValueType &pk, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr)
{
void on_primary_key(const char *, ValueType &pk, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
value_ = pk;
}
void on_primary_key(const char * /*id*/, std::string &pk, size_t size);
void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
template < class Type >
void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
static void on_attribute(const char * /*id*/, char * /*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
template<class Pointer>
void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {}
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*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *, ContainerType &, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_many_to_many(const char *, ContainerType &, const char * /*join_column*/, const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *, ContainerType &, const utils::foreign_attributes &/*attr*/) {}
static void on_has_many_to_many(const char *, ContainerType &, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many(const char *, ContainerType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
static void on_has_many(const char *, ContainerType &, const char * /*join_column*/, const utils::foreign_attributes &/*attr*/) {}
private:
utils::database_type value_{};

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

@ -5,6 +5,7 @@
#include "matador/query/internal/key_value_pair.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include <vector>
@ -28,11 +29,9 @@ public:
}
template < class V >
void on_primary_key(const char *id, V &x, typename std::enable_if<std::is_integral<V>::value && !std::is_same<bool, V>::value>::type* = 0)
{
void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
result_.emplace_back(id, x);
}
void on_primary_key(const char *id, std::string &, size_t);
void on_revision(const char *id, unsigned long long &/*rev*/);
template<typename Type>

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

@ -5,6 +5,7 @@
#include "matador/utils/attribute_writer.hpp"
#include "matador/utils/default_type_traits.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include <vector>
@ -25,11 +26,9 @@ public:
}
template<typename ValueType>
void on_primary_key(const char *, ValueType &x, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr)
{
utils::data_type_traits<ValueType>::bind_value(*this, 0, x);
void on_primary_key(const char *, ValueType &x, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
utils::data_type_traits<ValueType>::bind_value(*this, 0, x, attr.size());
}
void on_primary_key(const char *id, std::string &pk, size_t size);
void on_revision(const char *id, uint64_t &rev);
template < class Type >
void on_attribute(const char *, Type &x, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
@ -48,15 +47,15 @@ public:
values_.emplace_back(fk_value_extractor_.extract(*x));
}
template<class ContainerType>
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*/) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const char * /*inverse_join_column*/,
const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const utils::foreign_attributes &/*attr*/) {}

4
include/matador/sql/column_generator.hpp
View File

@ -4,6 +4,7 @@
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include "matador/sql/column.hpp"
@ -52,13 +53,12 @@ public:
}
template < class V >
void on_primary_key(const char *id, V &, std::enable_if_t<std::is_integral_v<V> && !std::is_same_v<bool, V>>* = nullptr) {
void on_primary_key(const char *id, V &, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
if (has_many_to_many_) {
return;
}
push(id);
}
void on_primary_key(const char *id, std::string &, size_t);
void on_revision(const char *id, unsigned long long &/*rev*/);
template<typename Type>

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

@ -7,6 +7,7 @@
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/primary_key_attribute.hpp"
namespace matador::sql {
@ -27,30 +28,29 @@ public:
}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr);
void on_primary_key(const char *id, std::string &value, size_t size);
void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
template < class Type >
void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
template < class Pointer >
void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template < class Pointer >
void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template<class ContainerType>
void on_has_many(const char * /*id*/,
static void on_has_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const char * /*inverse_join_column*/,
const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const utils::foreign_attributes &/*attr*/) {}
@ -74,16 +74,13 @@ public:
void reset();
template < class Type >
void on_primary_key(const char *id, Type &val, std::enable_if_t<std::is_integral_v<Type> && !std::is_same_v<bool, Type>>* = nullptr)
{
utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val);
void on_primary_key(const char *id, Type &val, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val, attr.size());
}
void on_primary_key(const char *id, std::string &, size_t size);
void on_revision(const char *id, uint64_t &/*rev*/);
template<typename Type>
void on_attribute(const char *id, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes)
{
void on_attribute(const char *id, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
utils::data_type_traits<Type>::read_value(*binder_, id, index_++, val);
}
void on_attribute(const char *id, char *value, const utils::field_attributes &attr = utils::null_attributes);
@ -91,28 +88,26 @@ public:
void on_attribute(const char *id, utils::value &val, const utils::field_attributes &attr = utils::null_attributes);
template<class Type, template < class ... > class Pointer>
void on_belongs_to(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes)
{
void on_belongs_to(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {
fk_result_binder_.bind(*x, id, index_++, *binder_);
}
template<class Type, template < class ... > class Pointer>
void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes)
{
void on_has_one(const char *id, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {
fk_result_binder_.bind(*x, id, index_++, *binder_);
}
template<class ContainerType>
void on_has_many(const char * /*id*/,
static void on_has_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const char * /*inverse_join_column*/,
const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const utils::foreign_attributes &/*attr*/) {}
@ -125,9 +120,8 @@ private:
namespace detail {
template<typename ValueType>
void fk_result_binder::on_primary_key(const char * /*id*/, ValueType &value, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> *)
{
utils::data_type_traits<ValueType>::read_value(*binder_, id_, index_++, value);
void fk_result_binder::on_primary_key(const char * /*id*/, ValueType &value, const utils::primary_key_attribute& attr) {
utils::data_type_traits<ValueType>::read_value(*binder_, id_, index_++, value, attr.size());
}
}

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

@ -6,6 +6,7 @@
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/default_type_traits.hpp"
#include "matador/utils/identifier.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include "matador/sql/interface/query_result_reader.hpp"
#include "matador/sql/internal/query_result_pk_resolver.hpp"
@ -37,9 +38,7 @@ public:
}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value,
std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> * = nullptr);
void on_primary_key(const char *id, std::string &value, size_t size);
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
void on_revision(const char * /*id*/, unsigned long long &/*rev*/) { ++column_index_; }
template<class Type>
@ -52,21 +51,20 @@ public:
}
template<class Pointer>
void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) { ++column_index_; }
template<class ContainerType>
void on_has_many(const char * /*id*/, ContainerType &, const char * /*join_column*/,
const utils::foreign_attributes &/*attr*/) {
void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/) {
++column_index_;
}
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &c, const char * /*join_column*/,
const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {
}
static void on_has_many(const char * /*id*/, ContainerType &, const char * /*join_column*/,
const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &c, const utils::foreign_attributes &/*attr*/) {
}
static void on_has_many_to_many(const char *id, ContainerType &c, const char * /*join_column*/,
const char * /*inverse_join_column*/, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
static void on_has_many_to_many(const char *id, ContainerType &c, const utils::foreign_attributes &/*attr*/) {}
private:
size_t column_index_{};
@ -82,16 +80,14 @@ public:
const std::vector<object::attribute_definition> &prototype, size_t column_index = 0);
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value,
std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> * = nullptr) {
utils::data_type_traits<ValueType>::read_value(*reader_, id, column_index_++, value);
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
utils::data_type_traits<ValueType>::read_value(*reader_, id, column_index_++, value, attr.size());
if (type_stack_.size() == 1) {
last_pk_ = current_pk_;
current_pk_ = value;
}
}
void on_primary_key(const char *id, std::string &value, size_t size);
void on_revision(const char *id, uint64_t &rev);
template<class Type>
@ -228,9 +224,8 @@ protected:
namespace detail {
template<typename ValueType>
void pk_reader::on_primary_key(const char *id, ValueType &value,
std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> *) {
utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_++, value);
void pk_reader::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());
}
}
}

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

@ -5,6 +5,7 @@
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/identifier.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include "matador/sql/interface/query_result_reader.hpp"
@ -27,15 +28,14 @@ public:
}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &/*value*/, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr) {
void on_primary_key(const char *id, ValueType &/*value*/, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
if (!type_stack_.empty()) {
return;
}
ValueType value;
utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_++, value);
utils::data_type_traits<ValueType>::read_value(reader_, id, column_index_++, value, attr.size());
pk_ = value;
}
void on_primary_key(const char *id, std::string &value, size_t size);
void on_revision(const char * /*id*/, unsigned long long &/*rev*/) { ++column_index_; }
template < class Type >
@ -48,11 +48,11 @@ public:
void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &attr) { on_foreign_key<typename Pointer::value_type>(attr.fetch() ); }
template<class ContainerType>
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*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &c, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &/*attr*/) {}
static void on_has_many_to_many(const char *id, ContainerType &c, const char *join_column, const char *inverse_join_column, const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char *id, ContainerType &c, const utils::foreign_attributes &/*attr*/) {}
static void on_has_many_to_many(const char *id, ContainerType &c, const utils::foreign_attributes &/*attr*/) {}
private:
template<class Type>

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

@ -7,6 +7,7 @@
#include "matador/utils/access.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/primary_key_attribute.hpp"
#include <string>
@ -27,30 +28,29 @@ public:
}
template<typename ValueType>
void on_primary_key(const char *id, ValueType &value, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>>* = nullptr);
void on_primary_key(const char *id, std::string &value, size_t size);
void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
void on_primary_key(const char *id, ValueType &value, const utils::primary_key_attribute& attr = utils::default_pk_attributes);
static void on_revision(const char * /*id*/, unsigned long long &/*rev*/) {}
template < class Type >
void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
template < class Pointer >
void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template < class Pointer >
void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template<class ContainerType>
void on_has_many(const char * /*id*/,
static void on_has_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const char * /*inverse_join_column*/,
const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const utils::foreign_attributes &/*attr*/) {}
@ -74,42 +74,37 @@ public:
void reset(size_t start_index);
template < class Type >
void on_primary_key(const char * /*id*/, Type &val, std::enable_if_t<std::is_integral_v<Type> && !std::is_same_v<bool, Type>>* = nullptr)
{
utils::data_type_traits<Type>::bind_value(*binder_, index_++, val);
void on_primary_key(const char * /*id*/, Type &val, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
utils::data_type_traits<Type>::bind_value(*binder_, index_++, val, attr.size());
}
void on_primary_key(const char *id, std::string &, size_t size);
void on_revision(const char *id, uint64_t &/*rev*/);
template<typename Type>
void on_attribute(const char * /*id*/, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes)
{
void on_attribute(const char * /*id*/, Type &val, const utils::field_attributes &/*attr*/ = utils::null_attributes) {
utils::data_type_traits<Type>::bind_value(*binder_, index_++, val);
}
template<class Type, template < class ... > class Pointer>
void on_belongs_to(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes)
{
void on_belongs_to(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {
fk_binder_.bind(*x, index_++, *binder_);
}
template<class Type, template < class ... > class Pointer>
void on_has_one(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes)
{
void on_has_one(const char * /*id*/, Pointer<Type> &x, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {
fk_binder_.bind(*x, index_++, *binder_);
}
template<class ContainerType>
void on_has_many(const char * /*id*/,
static void on_has_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const char * /*join_column*/,
const char * /*inverse_join_column*/,
const utils::foreign_attributes &/*attr*/) {}
template<class ContainerType>
void on_has_many_to_many(const char * /*id*/,
static void on_has_many_to_many(const char * /*id*/,
ContainerType &/*c*/,
const utils::foreign_attributes &/*attr*/) {}
@ -122,9 +117,8 @@ private:
namespace detail {
template<typename ValueType>
void fk_binder::on_primary_key(const char * /*id*/, ValueType &value, std::enable_if_t<std::is_integral_v<ValueType> && !std::is_same_v<bool, ValueType>> *)
{
utils::data_type_traits<ValueType>::bind_value(*binder_, index_++, value);
void fk_binder::on_primary_key(const char * /*id*/, ValueType &value, const utils::primary_key_attribute& attr) {
utils::data_type_traits<ValueType>::bind_value(*binder_, index_++, value, attr.size());
}
}

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

@ -15,6 +15,7 @@ class container;
namespace utils {
class field_attributes;
class foreign_attributes;
class primary_key_attribute;
}
namespace access {
@ -29,13 +30,13 @@ void process(Operator &op, const Type &object) {
}
template< class Operator, class Type >
void primary_key(Operator &op, const char *id, Type &value) {
op.on_primary_key(id, value);
void primary_key(Operator &op, const char *id, Type &value, const utils::primary_key_attribute &attr) {
op.on_primary_key(id, value, attr);
}
template< class Operator >
void primary_key(Operator &op, const char *id, std::string &value, size_t size ) {
op.on_primary_key(id, value, size);
template< class Operator, class Type >
void primary_key(Operator &op, const char *id, Type &value) {
op.on_primary_key(id, value);
}
template<class Operator>

62
include/matador/utils/default_type_traits.hpp
View File

@ -13,85 +13,85 @@ namespace matador::utils {
template <> struct data_type_traits<nullptr_t, void>
{
static basic_type type(std::size_t /*size*/) { return basic_type::type_null; }
static void read_value(attribute_reader &reader, const char *id, size_t index, nullptr_t &/*value*/);
static void bind_value(attribute_writer &binder, size_t index, nullptr_t &/*value*/);
static void read_value(attribute_reader &reader, const char *id, size_t index, nullptr_t &/*value*/, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, nullptr_t &/*value*/, size_t /*size*/ = 0);
};
template <> struct data_type_traits<int8_t, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int8; }
static void read_value(attribute_reader &reader, const char *id, size_t index, int8_t &value);
static void bind_value(attribute_writer &binder, size_t index, const int8_t &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, int8_t &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const int8_t &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<int16_t, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int16; }
static void read_value(attribute_reader &reader, const char *id, size_t index, int16_t &value);
static void bind_value(attribute_writer &binder, size_t index, const int16_t &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, int16_t &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const int16_t &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<int32_t, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int32; }
static void read_value(attribute_reader &reader, const char *id, size_t index, int32_t &value);
static void bind_value(attribute_writer &binder, size_t index, const int32_t &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, int32_t &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const int32_t &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<int64_t, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int64; }
static void read_value(attribute_reader &reader, const char *id, size_t index, int64_t &value);
static void bind_value(attribute_writer &binder, size_t index, const int64_t &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, int64_t &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const int64_t &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<uint8_t, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_uint8; }
static void read_value(attribute_reader &reader, const char *id, size_t index, uint8_t &value);
static void bind_value(attribute_writer &binder, size_t index, const uint8_t &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, uint8_t &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const uint8_t &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<uint16_t, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_uint16; }
static void read_value(attribute_reader &reader, const char *id, size_t index, uint16_t &value);
static void bind_value(attribute_writer &binder, size_t index, const uint16_t &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, uint16_t &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const uint16_t &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<uint32_t, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_uint32; }
static void read_value(attribute_reader &reader, const char *id, size_t index, uint32_t &value);
static void bind_value(attribute_writer &binder, size_t index, const uint32_t &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, uint32_t &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const uint32_t &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<uint64_t, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_uint64; }
static void read_value(attribute_reader &reader, const char *id, size_t index, uint64_t &value);
static void bind_value(attribute_writer &binder, size_t index, const uint64_t &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, uint64_t &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const uint64_t &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<bool, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_bool; }
static void read_value(attribute_reader &reader, const char *id, size_t index, bool &value);
static void bind_value(attribute_writer &binder, size_t index, const bool &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, bool &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const bool &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<float, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_float; }
static void read_value(attribute_reader &reader, const char *id, size_t index, float &value);
static void bind_value(attribute_writer &binder, size_t index, const float &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, float &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const float &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<double, void>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_double; }
static void read_value(attribute_reader &reader, const char *id, size_t index, double &value);
static void bind_value(attribute_writer &binder, size_t index, const double &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, double &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, const double &value, size_t /*size*/ = 0);
};
template <> struct data_type_traits<const char*, void>
@ -131,8 +131,8 @@ template <> struct data_type_traits<std::string, void>
template <> struct data_type_traits<utils::blob, void>
{
static basic_type type(std::size_t /*size*/) { return basic_type::type_blob; }
static void read_value(attribute_reader &reader, const char *id, size_t index, utils::blob &value);
static void bind_value(attribute_writer &binder, size_t index, utils::blob &value);
static void read_value(attribute_reader &reader, const char *id, size_t index, utils::blob &value, size_t /*size*/ = 0);
static void bind_value(attribute_writer &binder, size_t index, utils::blob &value, size_t /*size*/ = 0);
};
//template <> struct data_type_traits<matador::date, void>
@ -153,13 +153,11 @@ template < typename EnumType >
struct data_type_traits<EnumType, std::enable_if_t<std::is_enum_v<EnumType>>>
{
static basic_type type(std::size_t /*size*/ = 0) { return basic_type::type_int32; }
static void read_value(attribute_reader &reader, const char *id, const size_t index, EnumType &value)
{
data_type_traits<int>::read_value(reader, id, index, reinterpret_cast<int&>(value));
static void read_value(attribute_reader &reader, const char *id, const size_t index, EnumType &value, const size_t size = 0) {
data_type_traits<int>::read_value(reader, id, index, reinterpret_cast<int&>(value), size);
}
static void bind_value(attribute_writer &binder, const size_t index, EnumType &value)
{
data_type_traits<int>::bind_value(binder, index, static_cast<int &>(value));
static void bind_value(attribute_writer &binder, const size_t index, EnumType &value, const size_t size = 0) {
data_type_traits<int>::bind_value(binder, index, static_cast<int &>(value), size);
}
};
/// @endcond

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

@ -9,10 +9,10 @@ namespace matador::utils {
/**
* This class represents field attributes in
* form of size and constraints for a database
* the form of size and constraints for a database
* field (column)
*
* Currently the size is only applied
* Currently, the size is only applied
* to a field of type string leading
* to VARCHAR(size).
*/

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

@ -1,6 +1,8 @@
#ifndef PRIMARY_KEY_ATTRIBUTE_HPP
#define PRIMARY_KEY_ATTRIBUTE_HPP
#include "matador/utils/primary_key_generator_type.hpp"
#include <cstddef>
namespace matador::utils {
@ -18,6 +20,8 @@ public:
* @param size Size of the attribute
*/
primary_key_attribute(size_t size); // NOLINT(*-explicit-constructor)
primary_key_attribute(generator_type generator); // NOLINT(*-explicit-constructor)
primary_key_attribute(size_t size, generator_type generator);
~primary_key_attribute() = default;
primary_key_attribute(const primary_key_attribute &) = default;
primary_key_attribute(primary_key_attribute &&) = default;
@ -25,6 +29,7 @@ public:
primary_key_attribute &operator=(primary_key_attribute &&) = default;
primary_key_attribute& operator=(size_t size);
primary_key_attribute& operator=(generator_type generator);
/**
* Returns the size of the field
@ -33,9 +38,18 @@ public:
*/
[[nodiscard]] size_t size() const;
/**
* Returns the generator type of the field
*
* @return Generator type of the field
*/
[[nodiscard]] generator_type generator() const;
private:
size_t size_ = 0;
generator_type generator_ = generator_type::MANUALLY;
};
const primary_key_attribute default_pk_attributes {};
}
#endif //PRIMARY_KEY_ATTRIBUTE_HPP

13
include/matador/utils/primary_key_generator_type.hpp Normal file
View File

@ -0,0 +1,13 @@
#ifndef PRIMARY_KEY_GENERATOR_TYPE_HPP
#define PRIMARY_KEY_GENERATOR_TYPE_HPP
namespace matador::utils {
enum class generator_type {
MANUALLY,
AUTO,
IDENTITY,
SEQUENCE,
TABLE
};
}
#endif //PRIMARY_KEY_GENERATOR_TYPE_HPP

2
source/core/CMakeLists.txt
View File

@ -57,6 +57,7 @@ add_library(matador-core STATIC
../../include/matador/utils/os.hpp
../../include/matador/utils/placeholder.hpp
../../include/matador/utils/primary_key_attribute.hpp
../../include/matador/utils/primary_key_generator_type.hpp
../../include/matador/utils/result.hpp
../../include/matador/utils/singleton.hpp
../../include/matador/utils/string.hpp
@ -79,7 +80,6 @@ add_library(matador-core STATIC
object/foreign_node_completer.cpp
object/internal/shadow_schema.cpp
object/object_definition.cpp
object/primary_key_resolver.cpp
object/relation_endpoint.cpp
object/schema.cpp
object/schema_node.cpp

10
source/core/object/attribute_definition_generator.cpp
View File

@ -8,11 +8,6 @@ attribute_definition_generator::attribute_definition_generator(std::vector<objec
, repo_(repo)
{}
void attribute_definition_generator::on_primary_key(const char *id, std::string &pk, size_t size)
{
on_attribute(id, pk, { size, utils::constraints::PRIMARY_KEY });
}
void attribute_definition_generator::on_revision(const char *id, uint64_t &rev)
{
on_attribute(id, rev);
@ -26,9 +21,4 @@ void attribute_definition_generator::insert_missing_reference_column(const std::
const_cast<schema&>(repo_).missing_references_.insert({ti, ref_column});
}
void fk_attribute_generator::on_primary_key(const char *, std::string &, const size_t size)
{
type_ = utils::data_type_traits<std::string>::type(size);
}
}

10
source/core/object/primary_key_resolver.cpp
View File

@ -1,10 +0,0 @@
#include "matador/object/primary_key_resolver.hpp"
namespace matador::object {
void primary_key_resolver::on_primary_key(const char *id, const std::string &pk, size_t /*size*/) {
primary_key_info_.pk_column_name = id;
primary_key_info_.type = utils::basic_type::type_varchar;
primary_key_info_.pk = pk;
}
}

94
source/core/utils/default_type_traits.cpp
View File

@ -5,159 +5,129 @@
namespace matador::utils {
void data_type_traits<nullptr_t>::read_value(attribute_reader &/*reader*/, const char * /*id*/, size_t /*index*/, nullptr_t &/*value*/)
void data_type_traits<nullptr_t>::read_value(attribute_reader &/*reader*/, const char * /*id*/, size_t /*index*/, nullptr_t &/*value*/, const size_t /*size*/)
{}
void data_type_traits<nullptr_t>::bind_value(attribute_writer &/*binder*/, size_t /*index*/, nullptr_t &/*value*/)
void data_type_traits<nullptr_t>::bind_value(attribute_writer &/*binder*/, size_t /*index*/, nullptr_t &/*value*/, const size_t /*size*/)
{}
void data_type_traits<int8_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int8_t &value)
{
void data_type_traits<int8_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int8_t &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<int8_t>::bind_value(attribute_writer &binder, const size_t index, const int8_t &value)
{
void data_type_traits<int8_t>::bind_value(attribute_writer &binder, const size_t index, const int8_t &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<int16_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int16_t &value)
{
void data_type_traits<int16_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int16_t &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<int16_t>::bind_value(attribute_writer &binder, const size_t index, const int16_t &value)
{
void data_type_traits<int16_t>::bind_value(attribute_writer &binder, const size_t index, const int16_t &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<int32_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int32_t &value)
{
void data_type_traits<int32_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int32_t &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<int32_t>::bind_value(attribute_writer &binder, const size_t index, const int32_t &value)
{
void data_type_traits<int32_t>::bind_value(attribute_writer &binder, const size_t index, const int32_t &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<int64_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int64_t &value)
{
void data_type_traits<int64_t>::read_value(attribute_reader &reader, const char *id, const size_t index, int64_t &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<int64_t>::bind_value(attribute_writer &binder, const size_t index, const int64_t &value)
{
void data_type_traits<int64_t>::bind_value(attribute_writer &binder, const size_t index, const int64_t &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<uint8_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint8_t &value)
{
void data_type_traits<uint8_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint8_t &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<uint8_t>::bind_value(attribute_writer &binder, const size_t index, const uint8_t &value)
{
void data_type_traits<uint8_t>::bind_value(attribute_writer &binder, const size_t index, const uint8_t &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<uint16_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint16_t &value)
{
void data_type_traits<uint16_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint16_t &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<uint16_t>::bind_value(attribute_writer &binder, const size_t index, const uint16_t &value)
{
void data_type_traits<uint16_t>::bind_value(attribute_writer &binder, const size_t index, const uint16_t &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<uint32_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint32_t &value)
{
void data_type_traits<uint32_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint32_t &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<uint32_t>::bind_value(attribute_writer &binder, const size_t index, const uint32_t &value)
{
void data_type_traits<uint32_t>::bind_value(attribute_writer &binder, const size_t index, const uint32_t &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<uint64_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint64_t &value)
{
void data_type_traits<uint64_t>::read_value(attribute_reader &reader, const char *id, const size_t index, uint64_t &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<uint64_t>::bind_value(attribute_writer &binder, const size_t index, const uint64_t &value)
{
void data_type_traits<uint64_t>::bind_value(attribute_writer &binder, const size_t index, const uint64_t &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<bool>::read_value(attribute_reader &reader, const char *id, const size_t index, bool &value)
{
void data_type_traits<bool>::read_value(attribute_reader &reader, const char *id, const size_t index, bool &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<bool>::bind_value(attribute_writer &binder, const size_t index, const bool &value)
{
void data_type_traits<bool>::bind_value(attribute_writer &binder, const size_t index, const bool &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<float>::read_value(attribute_reader &reader, const char *id, const size_t index, float &value)
{
void data_type_traits<float>::read_value(attribute_reader &reader, const char *id, const size_t index, float &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<float>::bind_value(attribute_writer &binder, const size_t index, const float &value)
{
void data_type_traits<float>::bind_value(attribute_writer &binder, const size_t index, const float &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<double>::read_value(attribute_reader &reader, const char *id, const size_t index, double &value)
{
void data_type_traits<double>::read_value(attribute_reader &reader, const char *id, const size_t index, double &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<double>::bind_value(attribute_writer &binder, const size_t index, const double &value)
{
void data_type_traits<double>::bind_value(attribute_writer &binder, const size_t index, const double &value, const size_t /*size*/) {
binder.write_value(index, value);
}
void data_type_traits<const char*>::read_value(attribute_reader &reader, const char *id, const size_t index, const char* value, const size_t size)
{
void data_type_traits<const char*>::read_value(attribute_reader &reader, const char *id, const size_t index, const char* value, const size_t size) {
reader.read_value(id, index, const_cast<char*>(value), size);
}
void data_type_traits<const char *>::bind_value(attribute_writer &binder, const size_t index, const char *value, const size_t size)
{
void data_type_traits<const char *>::bind_value(attribute_writer &binder, const size_t index, const char *value, const size_t size) {
binder.write_value(index, value, size);
}
void data_type_traits<char*>::read_value(attribute_reader &reader, const char *id, const size_t index, char* value, const size_t size)
{
void data_type_traits<char*>::read_value(attribute_reader &reader, const char *id, const size_t index, char* value, const size_t size) {
reader.read_value(id, index, value, size);
}
void data_type_traits<char *>::bind_value(attribute_writer &binder, const size_t index, const char *value, const size_t size)
{
void data_type_traits<char *>::bind_value(attribute_writer &binder, const size_t index, const char *value, const size_t size) {
binder.write_value(index, value, size);
}
void data_type_traits<std::string>::read_value(attribute_reader &reader, const char *id, size_t index, std::string &value, size_t size)
{
void data_type_traits<std::string>::read_value(attribute_reader &reader, const char *id, const size_t index, std::string &value, const size_t size) {
reader.read_value(id, index, value, size);
}
void data_type_traits<std::string>::bind_value(attribute_writer &binder, size_t index, std::string &value, size_t size)
{
void data_type_traits<std::string>::bind_value(attribute_writer &binder, const size_t index, std::string &value, const size_t size) {
binder.write_value(index, value, size);
}
void data_type_traits<utils::blob, void>::read_value(attribute_reader &reader, const char *id, size_t index, utils::blob &value)
{
void data_type_traits<blob>::read_value(attribute_reader &reader, const char *id, const size_t index, utils::blob &value, const size_t /*size*/) {
reader.read_value(id, index, value);
}
void data_type_traits<utils::blob, void>::bind_value(attribute_writer &binder, size_t index, utils::blob &value)
{
void data_type_traits<blob>::bind_value(attribute_writer &binder, const size_t index, utils::blob &value, const size_t /*size*/) {
binder.write_value(index, value);
}

19
source/core/utils/primary_key_attribute.cpp
View File

@ -2,14 +2,31 @@
namespace matador::utils {
primary_key_attribute::primary_key_attribute(const size_t size)
: size_(size) {}
: size_( size ) {}
primary_key_attribute::primary_key_attribute(const generator_type generator)
: generator_( generator ) {}
primary_key_attribute::primary_key_attribute(const size_t size, const generator_type generator)
: size_( size )
, generator_( generator ) {}
primary_key_attribute& primary_key_attribute::operator=(const size_t size) {
size_ = size;
return *this;
}
primary_key_attribute& primary_key_attribute::operator=(const generator_type generator) {
generator_ = generator;
return *this;
}
size_t primary_key_attribute::size() const {
return size_;
}
generator_type primary_key_attribute::generator() const {
return generator_;
}
}

1
source/orm/CMakeLists.txt
View File

@ -71,7 +71,6 @@ add_library(matador-orm STATIC
query/attribute_string_writer.cpp
query/basic_condition.cpp
query/condition.cpp
query/fk_value_extractor.cpp
query/intermediates/executable_query.cpp
query/intermediates/fetchable_query.cpp
query/intermediates/query_create_intermediate.cpp

4
source/orm/orm/session_insert_builder.cpp
View File

@ -1,10 +1,6 @@
#include "matador/orm/session_insert_builder.hpp"
namespace matador::orm {
void session_insert_builder::on_primary_key(const char* id, std::string& value, size_t) {
push(id, value);
}
void session_insert_builder::on_revision(const char* id, unsigned long long& x) {
push(id, x);
}

8
source/orm/orm/session_query_builder.cpp
View File

@ -3,14 +3,6 @@
#include <iostream>
namespace matador::orm {
void session_query_builder::on_primary_key(const char *id, std::string &, size_t) {
push(id);
if (!is_root_entity()) {
const auto b = pk_.is_varchar();
std::cout << "is matching primary key: " << std::boolalpha << b << "\n";
}
}
void session_query_builder::on_revision(const char *id, unsigned long long &/*rev*/) {
push(id);
}

10
source/orm/query/fk_value_extractor.cpp
View File

@ -1,10 +0,0 @@
#include "matador/query/fk_value_extractor.hpp"
namespace matador::query::detail {
void fk_value_extractor::on_primary_key(const char *, std::string &pk, size_t)
{
value_ = pk;
}
}

10
source/orm/query/internal/query_result_impl.cpp
View File

@ -7,11 +7,6 @@ namespace matador::sql {
detail::pk_reader::pk_reader(query_result_reader &reader)
: reader_(reader) {}
void detail::pk_reader::on_primary_key(const char *id, std::string &value, size_t size)
{
utils::data_type_traits<std::string>::read_value(reader_, id, column_index_++, value, size);
}
query_result_impl::query_result_impl(std::unique_ptr<query_result_reader> &&reader, std::vector<object::attribute_definition> &&prototype, const size_t column_index)
: column_index_(column_index)
, prototype_(std::move(prototype))
@ -26,11 +21,6 @@ query_result_impl::query_result_impl(std::unique_ptr<query_result_reader> &&read
, pk_reader_(*reader_)
{}
void query_result_impl::on_primary_key(const char *id, std::string &value, size_t size)
{
utils::data_type_traits<std::string>::read_value(*reader_, id, column_index_++, value, size);
}
void query_result_impl::on_revision(const char *id, uint64_t &rev)
{
utils::data_type_traits<uint64_t>::read_value(*reader_, id, column_index_++, rev);

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

@ -4,13 +4,7 @@
namespace matador::query {
void key_value_generator::on_primary_key(const char *id, std::string &x, size_t)
{
result_.emplace_back(id, x);
}
void key_value_generator::on_revision(const char *id, unsigned long long int &x)
{
void key_value_generator::on_revision(const char *id, unsigned long long int &x) {
result_.emplace_back(id, x);
}

4
source/orm/query/query_compiler.cpp
View File

@ -275,8 +275,8 @@ void query_compiler::visit(internal::query_create_table_part &create_table_part)
}
for (const auto &[column, reference_column]: context.foreign_contexts) {
// ALTER TABLE Orders ADD CONSTRAINT FK_PersonOrder FOREIGN KEY (PersonID) REFERENCES Persons(PersonID);
std::string fk_cmd = "ALTER TABLE " + query_.table.name + " ADD";
fk_cmd += " CONSTRAINT FK_" + create_table_part.table().name;
std::string fk_cmd = "ALTER TABLE " + dialect_->prepare_identifier_string(query_.table.name) + " ADD";
fk_cmd += " CONSTRAINT FK_" + query_.table.name;
fk_cmd += "_" + column;
fk_cmd += " FOREIGN KEY (" + dialect_->prepare_identifier_string(column) + ")";
fk_cmd += " REFERENCES " + reference_column->table_name() + "(" + reference_column->name() + ")";

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

@ -6,11 +6,6 @@ value_extractor::value_extractor(std::vector<utils::database_type> &values)
: values_(values)
{}
void value_extractor::on_primary_key(const char *, std::string &pk, size_t s)
{
utils::data_type_traits<std::string>::bind_value(*this, 0, pk, s);
}
void value_extractor::on_revision(const char *, uint64_t &rev)
{
utils::data_type_traits<uint64_t>::bind_value(*this, 0, rev);

8
source/orm/sql/column_generator.cpp
View File

@ -18,14 +18,6 @@ column_generator::column_generator(std::vector<column> &column_infos,
seen_tables.insert(table_name);
}
void column_generator::on_primary_key(const char *id, std::string &, size_t)
{
if (has_many_to_many_) {
return;
}
push(id);
}
void column_generator::on_revision(const char *id, unsigned long long int &)
{
if (has_many_to_many_) {

14
source/orm/sql/internal/object_result_binder.cpp
View File

@ -4,25 +4,11 @@
namespace matador::sql {
namespace detail {
void fk_result_binder::on_primary_key(const char * /*id*/, std::string &value, const size_t size)
{
utils::data_type_traits<std::string>::read_value(*binder_, id_, index_++, value, size);
}
}
void object_result_binder::reset()
{
index_ = 0;
}
void object_result_binder::on_primary_key(const char *id, std::string &value, const size_t size)
{
utils::data_type_traits<std::string>::read_value(*binder_, id, index_++, value, size);
}
void object_result_binder::on_revision(const char *id, uint64_t &value)
{
utils::data_type_traits<uint64_t>::read_value(*binder_, id, index_++, value);

9
source/orm/sql/internal/query_result_pk_resolver.cpp
View File

@ -3,15 +3,6 @@
#include "matador/utils/value.hpp"
namespace matador::sql::internal {
void query_result_pk_resolver::on_primary_key(const char* id, std::string& /*value*/, const size_t size) {
if (!type_stack_.empty()) {
return;
}
std::string value;
utils::data_type_traits<std::string>::read_value(reader_, id, column_index_++, value, size);
pk_ = value;
}
void query_result_pk_resolver::on_attribute(const char *id, const utils::value &x, const utils::field_attributes &attr) {
if (is_constraint_set(attr.options(), utils::constraints::PRIMARY_KEY)) {
if (x.is_integer()) {

14
source/orm/sql/object_parameter_binder.cpp
View File

@ -3,25 +3,11 @@
namespace matador::sql {
namespace detail {
void fk_binder::on_primary_key(const char * /*id*/, std::string &value, size_t /*size*/)
{
utils::data_type_traits<std::string>::bind_value(*binder_, index_++, value);
}
}
void object_parameter_binder::reset(const size_t start_index)
{
index_ = start_index;
}
void object_parameter_binder::on_primary_key(const char * /*id*/, std::string &val, const size_t size)
{
utils::data_type_traits<std::string>::bind_value(*binder_, index_++, val, size);
}
void object_parameter_binder::on_revision(const char * /*id*/, uint64_t &rev)
{
utils::data_type_traits<uint64_t>::bind_value(*binder_, index_++, rev);

11
test/orm/query/QueryBuilderTest.cpp
View File

@ -12,9 +12,6 @@
#include "matador/utils/placeholder.hpp"
// #include "models/author.hpp"
// #include "models/book.hpp"
using namespace matador::test;
using namespace matador::object;
using namespace matador::sql;
@ -31,15 +28,17 @@ TEST_CASE_METHOD(QueryFixture, "Test create table sql statement string", "[query
REQUIRE(result == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL, "age" INTEGER NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##");
result = query::create()
auto ctx = query::create()
.table("person", {
make_pk_column<uint32_t>("id"),
make_column<std::string>("name", {255, constraints::UNIQUE}, null_option::NOT_NULL),
make_column<unsigned short>("age"),
make_fk_column<uint32_t>("address", "address", "id")
}).str(*db);
}).compile(*db);
REQUIRE(result == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL UNIQUE, "age" INTEGER NOT NULL, "address" BIGINT NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id), CONSTRAINT FK_person_address FOREIGN KEY (address) REFERENCES address(id)))##");
REQUIRE(ctx.sql == R"##(CREATE TABLE "person" ("id" BIGINT NOT NULL, "name" VARCHAR(255) NOT NULL UNIQUE, "age" INTEGER NOT NULL, "address" BIGINT NOT NULL, CONSTRAINT PK_person PRIMARY KEY (id)))##");
REQUIRE(ctx.additional_commands.size() == 1);
REQUIRE(ctx.additional_commands[0].sql == R"##(ALTER TABLE "person" ADD CONSTRAINT FK_person_address FOREIGN KEY ("address") REFERENCES address(id))##");
}
TEST_CASE_METHOD(QueryFixture, "Test drop table sql statement string", "[query]") {