Make session and connection_parameters movable

Implement move constructors for these classes and add unit tests for
them.

See SOCI#1098.

Author: olegendo

include/soci/connection-parameters.h

@@ -39,7 +39,9 @@ class SOCI_DECL connection_parameters
     explicit connection_parameters(std::string const & fullConnectString);
 
     connection_parameters(connection_parameters const& other);
+    connection_parameters(connection_parameters && other);
     connection_parameters& operator=(connection_parameters const& other);
+    connection_parameters& operator=(connection_parameters && other);
 
     ~connection_parameters();
 
@@ -77,6 +79,8 @@ class SOCI_DECL connection_parameters
     }
 
 private:
+    void reset_after_move();
+
     // The backend and connection string specified in our ctor.
     backend_factory const * factory_;
     std::string connectString_;

include/soci/session.h

@@ -55,6 +55,9 @@ class SOCI_DECL session
     explicit session(std::string const & connectString);
     explicit session(connection_pool & pool);
 
+    session(session &&other);
+    session &operator=(session &&other);
+
     ~session();
 
     void open(connection_parameters const & parameters);
@@ -191,6 +194,8 @@ class SOCI_DECL session
 private:
     SOCI_NOT_COPYABLE(session)
 
+    void reset_after_move();
+
     std::ostringstream query_stream_;
     std::unique_ptr<details::query_transformation_function> query_transformation_;
 

src/core/connection-parameters.cpp

@@ -119,6 +119,15 @@ connection_parameters::connection_parameters(connection_parameters const& other)
         backendRef_->inc_ref();
 }
 
+connection_parameters::connection_parameters(connection_parameters && other)
+    : factory_(std::move(other.factory_)),
+      connectString_(std::move(other.connectString_)),
+      backendRef_(std::move(other.backendRef_)),
+      options_(std::move(other.options_))
+{
+    other.reset_after_move();
+}
+
 connection_parameters& connection_parameters::operator=(connection_parameters const& other)
 {
     // Order is important in case of self-assignment.
@@ -135,10 +144,31 @@ connection_parameters& connection_parameters::operator=(connection_parameters co
     return *this;
 }
 
+connection_parameters& connection_parameters::operator=(connection_parameters && other)
+{
+    if (backendRef_ && backendRef_ != other.backendRef_)
+        backendRef_->dec_ref();
+
+    factory_ = std::move (other.factory_);
+    connectString_ = std::move(other.connectString_);
+    backendRef_ = std::move(other.backendRef_);
+    options_ = std::move(other.options_);
+
+    other.reset_after_move();
+
+    return *this;
+}
+
 connection_parameters::~connection_parameters()
 {
     if (backendRef_)
       backendRef_->dec_ref();
 }
 
+void connection_parameters::reset_after_move()
+{
+    factory_ = nullptr;
+    backendRef_ = nullptr;
+}
+
 } // namespace soci

src/core/session.cpp

@@ -134,6 +134,79 @@ session::session(connection_pool & pool)
     backEnd_ = pooledSession.get_backend();
 }
 
+session::session(session && other)
+    : once(std::move(other.once)),
+      prepare(std::move(other.prepare)),
+      query_stream_(std::move(other.query_stream_)),
+      query_transformation_(std::move(other.query_transformation_)),
+      logger_(std::move(other.logger_)),
+      lastConnectParameters_(std::move(other.lastConnectParameters_)),
+      uppercaseColumnNames_(std::move(other.uppercaseColumnNames_)),
+      backEnd_(std::move(other.backEnd_)),
+      gotData_(std::move(other.gotData_)),
+      isFromPool_(std::move(other.isFromPool_)),
+      poolPosition_(std::move(other.poolPosition_)),
+      pool_(std::move(other.pool_))
+{
+    if (!isFromPool_)
+    {
+        // If 'other' session was from a pool, 'once' and 'prepare'
+        // will have been already setup to point at the pooled session above.
+        // Otherwise reset them to reference 'this'.
+        once.set_session(this);
+        prepare.set_session(this);
+    }
+
+    other.reset_after_move ();
+}
+
+session& session::operator=(session && other)
+{
+    if (this != &other)
+    {
+        if (isFromPool_)
+        {
+            pool_->give_back(poolPosition_);
+        }
+        else if (backEnd_ != other.backEnd_)
+        {
+            delete backEnd_;
+        }
+
+        if (other.isFromPool_)
+        {
+            // If 'other' session was from a pool, 'once' and 'prepare'
+            // will have been already setup reference the pooled session above.
+            // Otherwise leave them alone and let them continue referencing 'this'.
+            once = std::move(other.once);
+            prepare = std::move(other.prepare);
+        }
+
+        query_stream_ = std::move(other.query_stream_);
+        query_transformation_ = std::move(other.query_transformation_);
+        logger_ = std::move(other.logger_);
+        lastConnectParameters_ = std::move(other.lastConnectParameters_);
+        uppercaseColumnNames_ = std::move(other.uppercaseColumnNames_);
+        backEnd_ = std::move(other.backEnd_);
+        gotData_ = std::move(other.gotData_);
+        isFromPool_ = std::move(other.isFromPool_);
+        poolPosition_ = std::move(other.poolPosition_);
+        pool_ = std::move(other.pool_);
+
+        other.reset_after_move();
+    }
+
+    return *this;
+}
+
+void session::reset_after_move()
+{
+    isFromPool_ = false;
+    pool_ = nullptr;
+    backEnd_ = nullptr;
+    pool_ = nullptr;
+}
+
 session::~session()
 {
     if (isFromPool_)

tests/common-tests.h

@@ -4319,6 +4319,37 @@ TEST_CASE_METHOD(common_tests, "Connection and reconnection", "[core][connect]")
         }
     }
 
+    {
+        // check move semantics of session
+
+        #if  __GNUC__ >= 13 || defined (__clang__)
+        SOCI_GCC_WARNING_SUPPRESS(self-move)
+        #endif
+
+        soci::session sql_0;
+        soci::session sql_1 = std::move(sql_0);
+
+        CHECK(!sql_0.is_connected());
+        CHECK(!sql_1.is_connected());
+
+        sql_0.open(backEndFactory_, connectString_);
+        CHECK(sql_0.is_connected());
+        CHECK(sql_0.get_backend());
+
+        sql_1 = std::move(sql_0);
+        CHECK(!sql_0.is_connected());
+        CHECK(!sql_0.get_backend());
+        CHECK(sql_1.is_connected());
+        CHECK(sql_1.get_backend());
+
+        sql_1 = std::move(sql_1);
+        CHECK(sql_1.is_connected());
+        CHECK(sql_1.get_backend());
+
+        #if __GNUC__ >= 13 || defined (__clang__)
+        SOCI_GCC_WARNING_RESTORE(self-move)
+        #endif
+    }
 }
 
 #ifdef SOCI_HAVE_BOOST