Ensure values being bound aren't passed by copy

Author: snej

include/sqnice/functions.hh

@@ -104,9 +104,7 @@ namespace sqnice {
         void operator= (uncopied_blob v) noexcept                {set_blob(v, false);}
 
         template <resultable T>
-        void operator= (T&& v) noexcept {
-            set_helper(*this, std::forward<T>(v));
-        }
+        void operator= (T const& v) noexcept                    {set_helper(*this, v);}
 
         using pointer_destructor = void(*)(void*);
 

include/sqnice/query.hh

@@ -204,17 +204,17 @@ namespace sqnice {
         }
 
         template <bindable T>
-        status bind(int idx, T&& v) {
-            return bind_helper(*this, idx, std::forward<T>(v));
+        status bind(int idx, T const& v) {
+            return bind_helper(*this, idx, v);
         }
 
         using pointer_destructor = void(*)(void*);
         status bind_pointer(int idx, void* pointer, const char* type, pointer_destructor);
 
         /// Binds a value to a named parameter.
         template <typename T>
-        status bind(char const* name, T&& v) {
-            return bind(check_parameter_index(name), std::forward<T>(v));
+        status bind(char const* name, T const& v) {
+            return bind(check_parameter_index(name), v);
         }
 
         sqlite3_stmt* stmt() const;
@@ -263,8 +263,8 @@ namespace sqnice {
         status bind_blob(int idx, blob value, bool copy);
 
         template <typename T, typename... Args>
-        void _bind_args(int idx, T&& arg, Args... rest) {
-            bind(idx, std::forward<T>(arg));
+        void _bind_args(int idx, T const& arg, Args&... rest) {
+            bind(idx, arg);
             if constexpr (sizeof...(rest) > 0)
                 _bind_args(idx + 1, rest...);
         }
@@ -280,7 +280,7 @@ namespace sqnice {
         /// Assigning a value to a `bindref` calls `bind` on the `statement`.
         /// @note  This returns `status`, not `*this`, which is unusual for an assignment operator.
         template <class T>
-        status operator= (T&& value)              {return stmt_.bind(idx_, std::forward<T>(value));}
+        status operator= (T const& value)               {return stmt_.bind(idx_, value);}
 
     private:
         friend class statement;
@@ -296,7 +296,7 @@ namespace sqnice {
     class statement::bindstream {
     public:
         template <class T>
-        bindstream& operator << (T&& v)     {stmt_.bind(idx_++, std::forward<T>(v)); return *this;}
+        bindstream& operator << (T const& value)        {stmt_.bind(idx_++, value); return *this;}
 
     private:
         friend class statement;
@@ -326,12 +326,12 @@ namespace sqnice {
 
         /// Binds parameters to the arguments, then executes the statement.
         template <typename... Args>
-        status execute(Args... args)                    {_bind_args(1, args...); return execute();}
+        status execute(Args&... args)                   {_bind_args(1, args...); return execute();}
 
         /// Binds parameters to the arguments, then executes the statement,
         /// but without throwing exceptions.
         template <typename... Args>
-        [[nodiscard]] status try_execute(Args... args) noexcept {
+        [[nodiscard]] status try_execute(Args&... args) noexcept {
             _bind_args(1,args...);
             return try_execute();
         }
@@ -358,10 +358,10 @@ namespace sqnice {
 
         /// Binds its arguments to multiple query parameters starting at index 1.
         template <typename... Args>
-        query& operator() (Args... args) & {_bind_args(1, args...); return *this;}
+        query& operator() (Args&... args) & {_bind_args(1, args...); return *this;}
 
         template <typename... Args>
-        [[nodiscard]] query operator() (Args... args) && {      // (variant avoids dangling ref to
+        [[nodiscard]] query operator() (Args&... args) && {     // (variant avoids dangling ref to
             _bind_args(1, args...); return std::move(*this);    // rvalue by returning a copy)
         }
 

test/testquery.cc

@@ -95,6 +95,29 @@ TEST_CASE_METHOD(sqnice_test, "SQNice bind null", "[sqnice]") {
     expect_eq(nullptr, address);
 }
 
+struct custom : sqnice::noncopyable { string str; void* self; };
+namespace sqnice {
+    inline status bind_helper(statement& stmt, int idx, custom const& c) {
+        REQUIRE(c.self == &c);
+        return stmt.bind(idx, uncopied(c.str));
+    }
+}
+
+TEST_CASE_METHOD(sqnice_test, "SQNice bind nocopy", "[sqnice]") {
+    sqnice::command cmd(db, "INSERT INTO contacts (name, phone) VALUES (?, ?)");
+    custom c;
+    c.str = "Longish name to ensure it gets heap allocated";
+    c.self = &c;
+    cmd.execute(c, "555-1234");
+
+    sqnice::query qry(db, "SELECT name, phone FROM contacts");
+    auto iter = qry.begin();
+    string name, phone;
+    (*iter).getter() >> name >> phone;
+    expect_eq("Longish name to ensure it gets heap allocated", name);
+    expect_eq("555-1234", phone);
+}
+
 TEST_CASE_METHOD(sqnice_test, "SQNice binder null", "[sqnice]") {
     sqnice::command cmd(db, "INSERT INTO contacts (name, phone, address) VALUES (?, ?, ?)");
     cmd.binder() << "Mike" << "555-1234" << nullptr;