added update_object_binder progress

backends/postgres/include/postgres_statement.hpp

@@ -15,7 +15,6 @@ 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;

backends/postgres/src/postgres_statement.cpp

@@ -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)
+: statement_impl(query, 0)
 , db_(db)
 , name_(std::move(name))
 {}
@@ -56,8 +56,6 @@ 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());
 }

include/matador/orm/session.hpp

@@ -188,6 +188,20 @@ 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>();
@@ -206,7 +220,9 @@ utils::result<object::object_ptr<Type>, utils::error> session::update( const obj
         return utils::failure(res.err());
     }
 
-    if (const auto update_result = res->bind(*obj).execute(); !update_result.is_ok()) {
+    res->bind(*obj);
+    update_object_binder binder(res.value());;
+    if (const auto update_result = binder.bind(*obj).execute(); !update_result.is_ok()) {
         return utils::failure(update_result.err());
     }
     return utils::ok(object::object_ptr{obj});

include/matador/query/key_value_generator.hpp

@@ -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*/);
 

include/matador/sql/interface/statement_impl.hpp

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

include/matador/sql/interface/statement_proxy.hpp

@@ -23,10 +23,17 @@ 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;
 

include/matador/sql/object_parameter_binder.hpp

@@ -1,68 +1,12 @@
 #ifndef QUERY_OBJECT_PARAMETER_BINDER_HPP
 #define QUERY_OBJECT_PARAMETER_BINDER_HPP
 
-#include "matador/utils/attribute_writer.hpp"
+#include "matador/sql/object_pk_binder.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;
@@ -75,10 +19,8 @@ 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>
@@ -88,11 +30,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) {
-    fk_binder_.bind(*x, index_++, *binder_);
+    pk_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) {
-    fk_binder_.bind(*x, index_++, *binder_);
+    pk_binder_.bind(*x, index_++, *binder_);
   }
   template<class ContainerType>
   static void on_has_many(const char * /*id*/,
@@ -113,17 +55,7 @@ public:
 private:
   utils::attribute_writer *binder_{};
   size_t index_{0};
-  detail::fk_binder fk_binder_;
+  object_pk_binder pk_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

include/matador/sql/object_pk_binder.hpp

@@ -0,0 +1,60 @@
+#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

include/matador/sql/statement.hpp

@@ -121,6 +121,21 @@ 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;

source/orm/sql/interface/statement_impl.cpp

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

source/orm/sql/interface/statement_proxy.cpp

@@ -7,14 +7,24 @@ 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;
 }

source/orm/sql/object_parameter_binder.cpp

@@ -1,13 +1,7 @@
 #include "matador/sql/object_parameter_binder.hpp"
-#include "matador/sql/interface/parameter_binder.hpp"
 
 namespace matador::sql {
-object_parameter_binder::object_parameter_binder(bool include_primary_key)
+void object_parameter_binder::reset(const size_t start_index) {
-: include_primary_key_(include_primary_key) {
-}
-
-void object_parameter_binder::reset(const size_t start_index)
-{
   index_ = start_index;
 }
 
@@ -15,8 +9,7 @@ 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);
 }
 

source/orm/sql/statement.cpp

@@ -86,11 +86,14 @@ 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();
 }