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

Compare commits

base: sascha:d3483ea5c2bbbbb43427551df549b45037891329
Branches Tags
sascha:main
sascha:feature/matador-ng
..
compare: sascha:24842f33130b02890b5af57e65ae7d3512d925d1
Branches Tags
sascha:feature/matador-ng
sascha:main

No commits in common. "d3483ea5c2bbbbb43427551df549b45037891329" and "24842f33130b02890b5af57e65ae7d3512d925d1" have entirely different histories.
d3483ea5c2 ... 24842f3313

13 changed files with 102 additions and 164 deletions
Show Stats Expand all files Collapse all files

1
backends/postgres/include/postgres_statement.hpp
View File

@ -15,6 +15,7 @@ public:
utils::result<size_t, utils::error> execute(const sql::parameter_binder& bindings) override;
utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> fetch(const sql::parameter_binder& bindings) override;
void reset() override;
protected:
[[nodiscard]] std::unique_ptr<utils::attribute_writer> create_binder() const override;

4
backends/postgres/src/postgres_statement.cpp
View File

@ -6,7 +6,7 @@
namespace matador::backends::postgres {
postgres_statement::postgres_statement(PGconn *db, std::string name, const sql::query_context &query)
: statement_impl(query, 0)
: statement_impl(query)
, db_(db)
, name_(std::move(name))
{}
@ -56,6 +56,8 @@ utils::result<std::unique_ptr<sql::query_result_impl>, utils::error> postgres_st
return utils::ok(std::make_unique<sql::query_result_impl>(std::make_unique<postgres_result_reader>(res), query_.prototype));
}
void postgres_statement::reset() {}
std::unique_ptr<utils::attribute_writer> postgres_statement::create_binder() const {
return std::make_unique<postgres_parameter_binder>(query_.bind_vars.size());
}

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

@ -188,20 +188,6 @@ utils::result<object::object_ptr<Type>, utils::error> session::insert( Args&&...
return insert(new Type(std::forward<Args>(args)...));
}
class update_object_binder final {
public:
explicit update_object_binder(sql::statement &stmt)
: stmt_(stmt) {}
template < class Type >
sql::statement& bind(Type &obj) {
return stmt_;
}
private:
sql::statement &stmt_;
sql::object_pk_binder pk_binder_;
};
template<typename Type>
utils::result<object::object_ptr<Type>, utils::error> session::update( const object::object_ptr<Type>& obj ) {
auto info = schema_->info<Type>();
@ -220,9 +206,7 @@ utils::result<object::object_ptr<Type>, utils::error> session::update( const obj
return utils::failure(res.err());
}
res->bind(*obj);
update_object_binder binder(res.value());;
if (const auto update_result = binder.bind(*obj).execute(); !update_result.is_ok()) {
if (const auto update_result = res->bind(*obj).execute(); !update_result.is_ok()) {
return utils::failure(update_result.err());
}
return utils::ok(object::object_ptr{obj});

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

@ -29,7 +29,7 @@ public:
template < class V >
void on_primary_key(const char *id, V &x, const utils::primary_key_attribute& /*attr*/ = utils::default_pk_attributes) {
result_.emplace_back(id, x);
// result_.emplace_back(id, x);
}
void on_revision(const char *id, uint64_t &/*rev*/);

22
include/matador/sql/interface/statement_impl.hpp
View File

@ -17,7 +17,7 @@ class sql_error;
class statement_impl
{
protected:
explicit statement_impl(query_context query, size_t start_bind_pos);
explicit statement_impl(query_context query);
public:
virtual ~statement_impl() = default;
@ -27,7 +27,7 @@ public:
template < class Type >
size_t bind_object(Type &obj, parameter_binder& bindings) {
object_parameter_binder object_binder_;
object_parameter_binder object_binder_(query_.command != sql_command::SQL_UPDATE);
object_binder_.reset(start_index());
object_binder_.bind(obj, bindings);
@ -36,21 +36,13 @@ public:
template < class Type >
void bind(const size_t pos, Type &val, parameter_binder& bindings) {
current_bind_pos_ = pos;
bind(val, bindings);
utils::data_type_traits<Type>::bind_value(bindings, adjust_index(pos), val);
}
template < class Type >
void bind(Type &val, parameter_binder& bindings) {
utils::data_type_traits<Type>::bind_value(bindings, adjust_index(current_bind_pos_++), val);
}
void bind(size_t pos, const char *value, size_t size, parameter_binder& bindings);
void bind(const char *value, size_t size, parameter_binder& bindings);
void bind(size_t pos, std::string &val, size_t size, parameter_binder& bindings);
void bind(std::string &value, size_t size, parameter_binder& bindings);
virtual void reset();
void bind(size_t pos, const char *value, size_t size, parameter_binder& bindings) const;
void bind(size_t pos, std::string &val, size_t size, parameter_binder& bindings) const;
[[nodiscard]] size_t bind_pos() const;
virtual void reset() = 0;
[[nodiscard]] const std::vector<std::string>& bind_vars() const;
[[nodiscard]] bool is_valid_host_var(const std::string &host_var, size_t pos) const;
@ -65,8 +57,6 @@ protected:
friend class statement_proxy;
query_context query_;
size_t start_bind_pos_{0};
size_t current_bind_pos_{0};
};
}

7
include/matador/sql/interface/statement_proxy.hpp
View File

@ -23,17 +23,10 @@ public:
void bind(size_t pos, Type &value, parameter_binder& bindings) {
statement_->bind(pos, value, bindings);
}
template<typename Type>
void bind(Type &value, parameter_binder& bindings) {
statement_->bind(value, bindings);
}
void bind(size_t pos, const char *value, size_t size, parameter_binder& bindings) const;
void bind(const char *value, size_t size, parameter_binder& bindings) const;
void bind(size_t pos, std::string &val, size_t size, parameter_binder& bindings) const;
void bind(std::string &val, size_t size, parameter_binder& bindings) const;
void reset() const;
[[nodiscard]] size_t bind_pos() const;
[[nodiscard]] std::string sql() const;

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

@ -1,12 +1,68 @@
#ifndef QUERY_OBJECT_PARAMETER_BINDER_HPP
#define QUERY_OBJECT_PARAMETER_BINDER_HPP
#include "matador/sql/object_pk_binder.hpp"
#include "matador/utils/attribute_writer.hpp"
#include "matador/utils/default_type_traits.hpp"
#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 {
namespace detail {
class fk_binder
{
public:
template<class Type>
void bind(Type &obj, const size_t column_index, utils::attribute_writer &binder)
{
binder_ = &binder;
index_ = column_index;
access::process(*this, obj);
binder_ = nullptr;
}
template<typename ValueType>
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 >
static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
template < class Pointer >
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template < class Pointer >
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template<class ContainerType>
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>
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:
utils::attribute_writer *binder_{};
size_t index_{0};
};
}
class object_parameter_binder {
public:
explicit object_parameter_binder(bool include_primary_key = true);
template<class Type>
void bind(Type &obj, utils::attribute_writer &binder) {
binder_ = &binder;
@ -19,8 +75,10 @@ public:
template < class Type >
void on_primary_key(const char * /*id*/, Type &val, const utils::primary_key_attribute& attr = utils::default_pk_attributes) {
if (include_primary_key_) {
utils::data_type_traits<Type>::bind_value(*binder_, index_++, val, attr.size());
}
}
void on_revision(const char *id, uint64_t &/*rev*/);
template<typename Type>
@ -30,11 +88,11 @@ public:
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) {
pk_binder_.bind(*x, index_++, *binder_);
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) {
pk_binder_.bind(*x, index_++, *binder_);
fk_binder_.bind(*x, index_++, *binder_);
}
template<class ContainerType>
static void on_has_many(const char * /*id*/,
@ -55,7 +113,17 @@ public:
private:
utils::attribute_writer *binder_{};
size_t index_{0};
object_pk_binder pk_binder_;
detail::fk_binder fk_binder_;
bool include_primary_key_{true};
};
namespace detail {
template<typename ValueType>
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());
}
}
}
#endif //QUERY_OBJECT_PARAMETER_BINDER_HPP

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

@ -1,60 +0,0 @@
#ifndef MATADOR_OBJECT_PK_BINDER_HPP
#define MATADOR_OBJECT_PK_BINDER_HPP
#include "matador/utils/access.hpp"
#include "matador/utils/attribute_writer.hpp"
#include "matador/utils/default_type_traits.hpp"
#include "matador/utils/field_attributes.hpp"
#include "matador/utils/foreign_attributes.hpp"
#include "matador/utils/primary_key_attribute.hpp"
namespace matador::sql {
class object_pk_binder {
public:
template<class Type>
void bind(Type &obj, const size_t column_index, utils::attribute_writer &binder) {
binder_ = &binder;
index_ = column_index;
access::process(*this, obj);
binder_ = nullptr;
}
template<typename ValueType>
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 >
static void on_attribute(const char * /*id*/, Type &/*x*/, const utils::field_attributes &/*attr*/ = utils::null_attributes) {}
template < class Pointer >
static void on_belongs_to(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template < class Pointer >
static void on_has_one(const char * /*id*/, Pointer &/*x*/, const utils::foreign_attributes &/*attr*/ = utils::default_foreign_attributes) {}
template<class ContainerType>
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>
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:
utils::attribute_writer *binder_{};
size_t index_{0};
};
template<typename ValueType>
void object_pk_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());
}
}
#endif //MATADOR_OBJECT_PK_BINDER_HPP

15
include/matador/sql/statement.hpp
View File

@ -121,21 +121,6 @@ public:
*/
void reset() const;
/**
* Returns the current binding position.
* Is set to the initial position after
* a call to reset().
*
* @return The current binding position
*/
[[nodiscard]] size_t bind_pos() const;
/**
* Returns the statements underlying SQL
* query string.
*
* @return The underlying SQL string
*/
[[nodiscard]] std::string sql() const;
[[nodiscard]] utils::result<std::unique_ptr<query_result_impl>, utils::error> fetch_internal() const;

31
source/orm/sql/interface/statement_impl.cpp
View File

@ -2,35 +2,16 @@
namespace matador::sql {
statement_impl::statement_impl(query_context query, const size_t start_bind_pos)
statement_impl::statement_impl(query_context query)
: query_(std::move(query))
, start_bind_pos_(start_bind_pos)
{}
void statement_impl::bind(const size_t pos, const char *value, const size_t size, parameter_binder& bindings) {
current_bind_pos_ = pos;
bind(value, size, bindings);
void statement_impl::bind(const size_t pos, const char *value, const size_t size, parameter_binder& bindings) const {
utils::data_type_traits<const char*>::bind_value(bindings, adjust_index(pos), value, size);
}
void statement_impl::bind(const char* value, const size_t size, parameter_binder& bindings) {
utils::data_type_traits<const char*>::bind_value(bindings, adjust_index(current_bind_pos_++), value, size);
}
void statement_impl::bind(const size_t pos, std::string &value, const size_t size, parameter_binder& bindings) {
current_bind_pos_ = pos;
bind(value, size, bindings);
}
void statement_impl::bind(std::string& value, const size_t size, parameter_binder& bindings) {
utils::data_type_traits<std::string>::bind_value(bindings, adjust_index(current_bind_pos_++), value, size);
}
void statement_impl::reset() {
current_bind_pos_ = start_bind_pos_;
}
size_t statement_impl::bind_pos() const {
return current_bind_pos_;
void statement_impl::bind(const size_t pos, std::string &val, const size_t size, parameter_binder& bindings) const {
utils::data_type_traits<std::string>::bind_value(bindings, adjust_index(pos), val, size);
}
const std::vector<std::string> &statement_impl::bind_vars() const {
@ -44,7 +25,7 @@ bool statement_impl::is_valid_host_var(const std::string &host_var, const size_t
}
size_t statement_impl::start_index() const {
return start_bind_pos_;
return 0;
}
size_t statement_impl::adjust_index(const size_t index) const {

10
source/orm/sql/interface/statement_proxy.cpp
View File

@ -7,24 +7,14 @@ statement_proxy::statement_proxy(std::unique_ptr<statement_impl>&& stmt)
void statement_proxy::bind(const size_t pos, const char* value, const size_t size, parameter_binder& bindings) const {
statement_->bind(pos, value, size, bindings);
}
void statement_proxy::bind(const char* value, const size_t size, parameter_binder& bindings) const {
statement_->bind(value, size, bindings);
}
void statement_proxy::bind(const size_t pos, std::string& val, const size_t size, parameter_binder& bindings) const {
statement_->bind(pos, val, size, bindings);
}
void statement_proxy::bind(std::string& val, const size_t size, parameter_binder& bindings) const {
statement_->bind(val, size, bindings);
}
void statement_proxy::reset() const {
statement_->reset();
}
size_t statement_proxy::bind_pos() const {
return statement_->bind_pos();
}
std::string statement_proxy::sql() const {
return statement_->query_.sql;
}

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

@ -1,7 +1,13 @@
#include "matador/sql/object_parameter_binder.hpp"
#include "matador/sql/interface/parameter_binder.hpp"
namespace matador::sql {
void object_parameter_binder::reset(const size_t start_index) {
object_parameter_binder::object_parameter_binder(bool include_primary_key)
: include_primary_key_(include_primary_key) {
}
void object_parameter_binder::reset(const size_t start_index)
{
index_ = start_index;
}
@ -9,7 +15,8 @@ size_t object_parameter_binder::current_index() const {
return index_;
}
void object_parameter_binder::on_revision(const char * /*id*/, uint64_t &rev) {
void object_parameter_binder::on_revision(const char * /*id*/, uint64_t &rev)
{
utils::data_type_traits<uint64_t>::bind_value(*binder_, index_++, rev);
}

7
source/orm/sql/statement.cpp
View File

@ -86,14 +86,11 @@ utils::result<std::optional<record>, utils::error> statement::fetch_one() const
return utils::ok(std::optional{*first.release()});
}
void statement::reset() const {
void statement::reset() const
{
statement_proxy_->reset();
}
size_t statement::bind_pos() const {
return statement_proxy_->bind_pos();
}
std::string statement::sql() const {
return statement_proxy_->sql();
}