Threadsafe connection

README.md

@@ -14,6 +14,8 @@
 # SQLite ORM
 SQLite ORM light header only library for modern C++. Please read the license precisely. The project has AGPL license for open source project and MIT license after purchasing it for 50$ (using [PayPal](https://paypal.me/fnc12) or any different way (contact using email [email protected])).
 
+Documentation is found in [docs](docs/home.md).
+
 # Status
 | Branch | Travis | Appveyor |
 | :----- | :----- | :------- |

dev/backup.h

@@ -28,15 +28,15 @@ namespace sqlite_orm {
                      const std::string& zSourceName,
                      std::unique_ptr<connection_holder> holder_) :
                 handle(sqlite3_backup_init(to_.get(), zDestName.c_str(), from_.get(), zSourceName.c_str())),
-                holder(std::move(holder_)), to(to_), from(from_) {
+                holder(std::move(holder_)), to(std::move(to_)), from(std::move(from_)) {
                 if (!this->handle) {
                     throw std::system_error{orm_error_code::failed_to_init_a_backup};
                 }
             }
 
             backup_t(backup_t&& other) :
-                handle(std::exchange(other.handle, nullptr)), holder(std::move(other.holder)), to(other.to),
-                from(other.from) {}
+                handle(std::exchange(other.handle, nullptr)), holder(std::move(other.holder)), to(std::move(other.to)),
+                from(std::move(other.from)) {}
 
             ~backup_t() {
                 if (this->handle) {

dev/functional/cxx_new.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifdef SQLITE_ORM_IMPORT_STD_MODULE
+#include <version>
+#else
+#include <new>
+#endif
+
+namespace sqlite_orm {
+    namespace internal {
+        namespace polyfill {
+#if __cpp_lib_hardware_interference_size >= 201703L
+            using std::hardware_constructive_interference_size;
+            using std::hardware_destructive_interference_size;
+#else
+            constexpr size_t hardware_constructive_interference_size = 64;
+            constexpr size_t hardware_destructive_interference_size = 64;
+#endif
+        }
+    }
+
+    namespace polyfill = internal::polyfill;
+}

dev/functional/cxx_scope_guard.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#ifndef SQLITE_ORM_IMPORT_STD_MODULE
+#include <utility>  // std::forward
+#endif
+
+namespace sqlite_orm::internal {
+    /*  
+        Poor-man's scope (exit) guard until C++29 finally comes with proper standard facilities [Draft D3610].
+     */
+    template<class F>
+    class scope_guard {
+      public:
+        explicit scope_guard(F&& exitFunction) : _exitFunction{std::forward<F>(exitFunction)} {}
+
+        ~scope_guard() {
+            _exitFunction();
+        }
+
+      private:
+        F _exitFunction;
+    };
+}

dev/limit_accessor.h

@@ -3,8 +3,8 @@
 #include <sqlite3.h>
 #ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <map>  //  std::map
-#include <functional>  //  std::function
-#include <memory>  //  std::shared_ptr
+#include <functional>  //  std::function, std::reference_wrapper
+#include <utility>  //  std::move
 #endif
 
 #include "connection_holder.h"
@@ -14,9 +14,7 @@ namespace sqlite_orm {
     namespace internal {
 
         struct limit_accessor {
-            using get_connection_t = std::function<connection_ref()>;
-
-            limit_accessor(get_connection_t get_connection_) : get_connection(std::move(get_connection_)) {}
+            limit_accessor(std::unique_ptr<connection_holder>& connection) : connection{connection} {}
 
             int length() {
                 return this->get(SQLITE_LIMIT_LENGTH);
@@ -117,7 +115,7 @@ namespace sqlite_orm {
 #endif
 
           protected:
-            get_connection_t get_connection;
+            std::reference_wrapper<std::unique_ptr<connection_holder>> connection;
 
             friend struct storage_base;
 
@@ -127,14 +125,15 @@ namespace sqlite_orm {
             std::map<int, int> limits;
 
             int get(int id) {
-                auto connection = this->get_connection();
+                connection_ref connection = *this->connection.get();
                 return sqlite3_limit(connection.get(), id, -1);
             }
 
             void set(int id, int newValue) {
                 this->limits[id] = newValue;
-                auto connection = this->get_connection();
-                sqlite3_limit(connection.get(), id, newValue);
+                if (connection_ptr maybeConnection = *this->connection.get()) {
+                    sqlite3_limit(maybeConnection.get(), id, newValue);
+                }
             }
         };
     }

dev/statement_serializer.h

@@ -12,6 +12,9 @@
 #include <memory>
 #include <array>
 #include <list>  //  std::list
+#ifdef SQLITE_ORM_CPP20_RANGES_SUPPORTED
+#include <ranges>  //  std::views::transform
+#endif
 #endif
 #include "functional/cxx_string_view.h"
 #include "functional/cxx_optional.h"
@@ -1501,6 +1504,9 @@ namespace sqlite_orm {
                                                             const Ctx&) SQLITE_ORM_OR_CONST_CALLOP {
                 std::stringstream ss;
                 ss << "SET ";
+#ifdef SQLITE_ORM_CPP20_RANGES_SUPPORTED
+                ss << streaming_serialized(statement | std::views::transform(&dynamic_set_entry::serialized_value));
+#else
                 int index = 0;
                 for (const dynamic_set_entry& entry: statement) {
                     if (index > 0) {
@@ -1509,6 +1515,7 @@ namespace sqlite_orm {
                     ss << entry.serialized_value;
                     ++index;
                 }
+#endif
                 return ss.str();
             }
         };

dev/storage.h

@@ -146,7 +146,7 @@ namespace sqlite_orm {
                 context_t context{this->db_objects};
                 statement_serializer<Table, void> serializer;
                 const std::string sql = serializer.serialize(table, context, tableName);
-                this->executor.perform_void_exec(db, sql.data());
+                this->executor.perform_void_exec(db, sql.c_str());
             }
 
             /**
@@ -169,7 +169,7 @@ namespace sqlite_orm {
                        << streaming_identifier(columnName) << std::flush;
                     sql = ss.str();
                 }
-                this->executor.perform_void_exec(db, sql.data());
+                this->executor.perform_void_exec(db, sql.c_str());
             }
 #endif
 
@@ -278,8 +278,8 @@ namespace sqlite_orm {
             mapped_view<O, self_type, Args...> iterate(Args&&... args) {
                 this->assert_mapped_type<O>();
 
-                auto connection = this->get_connection();
-                return {*this, std::move(connection), std::forward<Args>(args)...};
+                auto conRef = this->get_connection();
+                return {*this, std::move(conRef), std::forward<Args>(args)...};
             }
 
 #ifdef SQLITE_ORM_WITH_CPP20_ALIASES
@@ -313,8 +313,8 @@ namespace sqlite_orm {
                 if constexpr (is_select_v<Select>) {
                     expression.highest_level = true;
                 }
-                auto con = this->get_connection();
-                return {this->db_objects, std::move(con), std::move(expression)};
+                auto conRef = this->get_connection();
+                return {this->db_objects, std::move(conRef), std::move(expression)};
             }
 
 #ifdef SQLITE_ORM_CPP23_GENERATOR_SUPPORTED
@@ -1235,7 +1235,7 @@ namespace sqlite_orm {
                        << serialize(column, context) << std::flush;
                     sql = ss.str();
                 }
-                this->executor.perform_void_exec(db, sql.data());
+                this->executor.perform_void_exec(db, sql.c_str());
             }
 
             template<class ColResult, class S>
@@ -1286,10 +1286,10 @@ namespace sqlite_orm {
                 context.omit_table_name = false;
                 context.replace_bindable_with_question = true;
 
-                auto conection = this->get_connection();
                 const std::string sql = serialize(statement, context);
-                sqlite3_stmt* stmt = prepare_stmt(conection.get(), sql);
-                return prepared_statement_t<S>{std::forward<S>(statement), stmt, std::move(conection)};
+                auto conRef = this->get_connection();
+                sqlite3_stmt* stmt = prepare_stmt(conRef.get(), sql);
+                return prepared_statement_t<S>{std::forward<S>(statement), stmt, std::move(conRef)};
             }
 
           public:
@@ -1321,9 +1321,9 @@ namespace sqlite_orm {
              * can be printed out on std::ostream with `operator<<`.
              */
             std::map<std::string, sync_schema_result> sync_schema(bool preserve = false) {
-                auto con = this->get_connection();
+                auto conRef = this->get_connection();
                 std::map<std::string, sync_schema_result> result;
-                iterate_tuple<true>(this->db_objects, [this, db = con.get(), preserve, &result](auto& schemaObject) {
+                iterate_tuple<true>(this->db_objects, [this, db = conRef.get(), preserve, &result](auto& schemaObject) {
                     sync_schema_result status = this->sync_dbo(schemaObject, db, preserve);
                     result.emplace(schemaObject.name, status);
                 });
@@ -1336,9 +1336,9 @@ namespace sqlite_orm {
              *  what will happen if you sync your schema.
              */
             std::map<std::string, sync_schema_result> sync_schema_simulate(bool preserve = false) {
-                auto con = this->get_connection();
+                auto conRef = this->get_connection();
                 std::map<std::string, sync_schema_result> result;
-                iterate_tuple<true>(this->db_objects, [this, db = con.get(), preserve, &result](auto& schemaObject) {
+                iterate_tuple<true>(this->db_objects, [this, db = conRef.get(), preserve, &result](auto& schemaObject) {
                     sync_schema_result status = this->schema_status(schemaObject, db, preserve, nullptr);
                     result.emplace(schemaObject.name, status);
                 });