Threadsafe connection

dev/connection_holder.h

@@ -3,11 +3,14 @@
 #include <sqlite3.h>
 #ifndef SQLITE_ORM_IMPORT_STD_MODULE
 #include <atomic>
+#ifdef SQLITE_ORM_CPP20_SEMAPHORE_SUPPORTED
+#include <semaphore>
+#endif
 #include <functional>  //  std::function
 #include <string>  //  std::string
 #endif
 
-#include "functional/gsl.h"
+#include "functional/cxx_new.h"
 #include "error_code.h"
 #include "vfs_name.h"
 #include "db_open_mode.h"
@@ -16,6 +19,127 @@
 namespace sqlite_orm {
     namespace internal {
 
+#ifdef SQLITE_ORM_CPP20_SEMAPHORE_SUPPORTED
+        /** 
+         *  The connection holder should be performant in all variants:
+            1. single-threaded use
+            2. opened once (open forever)
+            3. concurrent open/close
+
+            Hence, a light-weight binary semaphore is used to synchronize opening and closing a database connection.
+        */
+        struct connection_holder {
+            struct maybe_lock {
+                maybe_lock(std::binary_semaphore& sync, bool shouldLock) noexcept(noexcept(sync.acquire())) :
+                    isSynced{shouldLock}, sync{sync} {
+                    if (shouldLock) {
+                        sync.acquire();
+                    }
+                }
+
+                ~maybe_lock() {
+                    if (isSynced) {
+                        sync.release();
+                    }
+                }
+
+                const bool isSynced;
+                std::binary_semaphore& sync;
+            };
+
+            connection_holder(std::string filename,
+                              std::function<void(sqlite3*)> didOpenDb,
+                              const connection_control& options = {}) :
+                _didOpenDb{std::move(didOpenDb)}, filename(std::move(filename)), vfs_name(options.vfs_name),
+                open_mode(options.open_mode) {}
+
+            connection_holder(const connection_holder&) = delete;
+
+            connection_holder(const connection_holder& other, std::function<void(sqlite3*)> didOpenDb) :
+                _didOpenDb{std::move(didOpenDb)}, filename{other.filename}, vfs_name(other.vfs_name),
+                open_mode{other.open_mode} {}
+
+            void retain() {
+                const maybe_lock maybeLock{_sync, !_openedForeverHint};
+
+                // `maybeLock.isSynced`: the lock above already synchronized everything, so we can just atomically increment the counter
+                // `!maybeLock.isSynced`: we presume that the connection is opened once in a single-threaded context [also open forever].
+                //                        therefore we can just use an atomic increment but don't need sequencing due to `prevCount > 0`.
+                if (int prevCount = _retainCount.fetch_add(1, std::memory_order_relaxed); prevCount > 0) {
+                    return;
+                }
+
+                // first one opens and sets up the connection.
+
+                int open_flags = internal::db_open_mode_to_int_flags(this->open_mode);
+#if SQLITE_VERSION_NUMBER >= 3037002
+                open_flags |= SQLITE_OPEN_EXRESCODE;
+#endif
+
+                if (int rc = sqlite3_open_v2(this->filename.c_str(), &this->db, open_flags, this->vfs_name.c_str());
+                    rc != SQLITE_OK) [[unlikely]] /*possible, but unexpected*/ {
+                    throw_translated_sqlite_error(this->db);
+                }
+
+                if (_didOpenDb) {
+                    _didOpenDb(this->db);
+                }
+            }
+
+            void release() {
+                const maybe_lock maybeLock{_sync, !_openedForeverHint};
+
+                if (int prevCount = _retainCount.fetch_sub(
+                        1,
+                        maybeLock.isSynced
+                            // the lock above already synchronized everything, so we can just atomically decrement the counter
+                            ? std::memory_order_relaxed
+                            // the counter must serve as a synchronization point
+                            : std::memory_order_acq_rel);
+                    prevCount > 1) {
+                    return;
+                }
+
+                // last one closes the connection.
+
+                if (int rc = sqlite3_close_v2(this->db); rc != SQLITE_OK) [[unlikely]] {
+                    throw_translated_sqlite_error(this->db);
+                } else {
+                    this->db = nullptr;
+                }
+            }
+
+            sqlite3* get() const {
+                // note: ensuring a valid DB handle was already memory ordered with `retain()`
+                return this->db;
+            }
+
+            /** 
+             *  @attention While retrieving the reference count value is atomic it makes only sense at single-threaded points in code.
+             */
+            int retain_count() const {
+                return _retainCount.load(std::memory_order_relaxed);
+            }
+
+          protected:
+            SQLITE_ORM_MSVC_SUPPRESS_OVERALIGNMENT(alignas(polyfill::hardware_destructive_interference_size))
+            orm_gsl::owner<sqlite3*> db = nullptr;
+
+          private:
+            std::atomic_int _retainCount{};
+            const bool _openedForeverHint = false;
+            std::binary_semaphore _sync{1};
+
+          private:
+            SQLITE_ORM_MSVC_SUPPRESS_OVERALIGNMENT(alignas(polyfill::hardware_destructive_interference_size))
+            const std::function<void(sqlite3* db)> _didOpenDb;
+
+          public:
+            const std::string filename;
+            const std::string vfs_name;
+            const db_open_mode open_mode;
+        };
+#else
         struct connection_holder {
             connection_holder(std::string filename,
                               std::function<void(sqlite3*)> didOpenDb,
@@ -78,19 +202,22 @@ namespace sqlite_orm {
             }
 
           protected:
+            SQLITE_ORM_MSVC_SUPPRESS_OVERALIGNMENT(alignas(polyfill::hardware_destructive_interference_size))
             orm_gsl::owner<sqlite3*> db = nullptr;
 
           private:
             std::atomic_int _retainCount{};
 
           private:
+            SQLITE_ORM_MSVC_SUPPRESS_OVERALIGNMENT(alignas(polyfill::hardware_destructive_interference_size))
             const std::function<void(sqlite3* db)> _didOpenDb;
 
           public:
             const std::string filename;
             const std::string vfs_name;
             const db_open_mode open_mode;
         };
+#endif
 
         struct connection_ref {
             connection_ref(connection_holder& holder) : holder(&holder) {

dev/functional/config.h

@@ -47,6 +47,10 @@
 #define SQLITE_ORM_CPP20_RANGES_SUPPORTED
 #endif
 
+#if __cpp_lib_semaphore >= 201907L
+#define SQLITE_ORM_CPP20_SEMAPHORE_SUPPORTED
+#endif
+
 #ifdef SQLITE_ORM_STATIC_CALL_OPERATOR_SUPPORTED
 #define SQLITE_ORM_STATIC_CALLOP static
 #define SQLITE_ORM_OR_CONST_CALLOP

dev/functional/cxx_compiler_quirks.h

@@ -20,6 +20,16 @@
 #define SQLITE_ORM_CLANG_SUPPRESS(warnoption, ...) __VA_ARGS__
 #endif
 
+#if defined(_MSC_VER) && !defined(__clang__)
+#define SQLITE_ORM_DO_PRAGMA(...) __pragma(__VA_ARGS__)
+#endif
+
+#if defined(_MSC_VER) && !defined(__clang__)
+#define SQLITE_ORM_MSVC_SUPPRESS(warncode, ...) SQLITE_ORM_DO_PRAGMA(warning(suppress : warncode))
+#else
+#define SQLITE_ORM_MSVC_SUPPRESS(warcode, ...) __VA_ARGS__
+#endif
+
 // clang has the bad habit of diagnosing missing brace-init-lists when constructing aggregates with base classes.
 // This is a false positive, since the C++ standard is quite clear that braces for nested or base objects may be omitted,
 // see https://en.cppreference.com/w/cpp/language/aggregate_initialization:
@@ -30,6 +40,9 @@
 // Because we know what we are doing, we suppress the diagnostic message
 #define SQLITE_ORM_CLANG_SUPPRESS_MISSING_BRACES(...) SQLITE_ORM_CLANG_SUPPRESS("-Wmissing-braces", __VA_ARGS__)
 
+// msvc has the bad habit of diagnosing overalignment of types with an explicit alignment specifier.
+#define SQLITE_ORM_MSVC_SUPPRESS_OVERALIGNMENT(...) SQLITE_ORM_MSVC_SUPPRESS(4324, __VA_ARGS__)
+
 #if defined(_MSC_VER) && (_MSC_VER < 1920)
 #define SQLITE_ORM_BROKEN_VARIADIC_PACK_EXPANSION
 // Type replacement may fail if an alias template has a non-type template parameter from a dependent expression in it,

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/storage.h

@@ -1783,7 +1783,7 @@ namespace sqlite_orm {
                 if (this->executor.did_run_query) {
                     this->executor.did_run_query(sql);
                 }
-                switch (stepRes) {
+                switch (rc) {
                     case SQLITE_ROW: {
                         T res;
                         object_from_column_builder<T> builder{res, stmt};
@@ -1954,9 +1954,6 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
             create_from_tuple<std::tuple>(std::move(specTuple), opt_index_sequence<decltype(specTuple)>{}));
     }
 #else
-    /*
-     *  Factory function for a storage instance, from a database file and a bunch of database object definitions.
-     */
     template<class... DBO>
     internal::storage_t<DBO...> make_storage(std::string filename, DBO... dbObjects) {
         return {std::move(filename), {std::forward<DBO>(dbObjects)...}, std::tuple<>{}};