Merge pull request #1393 from Minimal-Audio/feature/1392-support-sqlite-vfs

trueqbit · web-flow · commit 564afba4ccd4 · 2025-04-03T11:28:49.000+03:00
Added support for choosing the SQLite VFS and open mode flags
diff --git a/dev/connection_holder.h b/dev/connection_holder.h
@@ -8,33 +8,38 @@
 #endif
 
 #include "error_code.h"
+#include "vfs_name.h"
+#include "db_open_mode.h"
+#include "storage_options.h"
 
 namespace sqlite_orm {
     namespace internal {
 
         struct connection_holder {
-            connection_holder(std::string filename, std::function<void(sqlite3*)> didOpenDb) :
-                _didOpenDb{std::move(didOpenDb)}, filename(std::move(filename)) {}
+            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} {}
+                _didOpenDb{std::move(didOpenDb)}, filename{other.filename}, vfs_name(other.vfs_name),
+                open_mode{other.open_mode} {}
 
             void retain() {
                 // first one opens the connection.
                 // 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 (_retainCount.fetch_add(1, std::memory_order_relaxed) == 0) {
-                    int rc = sqlite3_open_v2(this->filename.c_str(),
-                                             &this->db,
-                                             SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
+                    int open_flags = internal::db_open_mode_to_int_flags(this->open_mode);
 #if SQLITE_VERSION_NUMBER >= 3008008
-                                                 | SQLITE_OPEN_EXRESCODE,
-#else
-                                                 | 0,
+                    open_flags |= SQLITE_OPEN_EXRESCODE;
 #endif
-                                             nullptr);
+
+                    int rc = sqlite3_open_v2(this->filename.c_str(), &this->db, open_flags, this->vfs_name.c_str());
+
                     if (rc != SQLITE_OK) SQLITE_ORM_CPP_UNLIKELY /*possible, but unexpected*/ {
                         throw_translated_sqlite_error(rc);
                     }
@@ -81,6 +86,8 @@ namespace sqlite_orm {
 
           public:
             const std::string filename;
+            const std::string vfs_name;
+            const db_open_mode open_mode;
         };
 
         struct connection_ref {
diff --git a/dev/db_open_mode.h b/dev/db_open_mode.h
@@ -0,0 +1,26 @@
+#pragma once
+
+SQLITE_ORM_EXPORT namespace sqlite_orm {
+
+    enum class db_open_mode {
+        default_ = 0,
+        create_readwrite = 0,
+        readonly = 1,
+    };
+}
+
+SQLITE_ORM_EXPORT namespace sqlite_orm {
+    namespace internal {
+        constexpr int db_open_mode_to_int_flags(db_open_mode open) {
+
+            switch (open) {
+                case db_open_mode::readonly:
+                    return SQLITE_OPEN_READONLY;
+                case db_open_mode::create_readwrite:
+                    return SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE;
+            };
+
+            return -1;
+        }
+    }
+}
diff --git a/dev/functional/config.h b/dev/functional/config.h
@@ -72,6 +72,15 @@
 
 #define SQLITE_ORM_WITH_CTE
 
+#if defined(_WIN32)
+#define SQLITE_ORM_WIN
+#elif defined(__APPLE__)
+#define SQLITE_ORM_APPLE
+#define SQLITE_ORM_UNIX
+#elif defined(__unix__) || defined(__unix) || defined(__linux__) || defined(__FreeBSD__)
+#define SQLITE_ORM_UNIX
+#endif
+
 // define the inline namespace "literals" so that it is available even if it was not introduced by a feature
 namespace sqlite_orm {
     inline namespace literals {}
diff --git a/dev/serialize_result_type.h b/dev/serialize_result_type.h
@@ -12,9 +12,11 @@ namespace sqlite_orm {
 #ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED
         using serialize_result_type = std::string_view;
         using serialize_arg_type = std::string_view;
+        using string_constant_type = std::string_view;
 #else
         using serialize_result_type = std::string;
         using serialize_arg_type = const std::string&;
+        using string_constant_type = const char*;
 #endif
     }
 }
diff --git a/dev/storage_base.h b/dev/storage_base.h
@@ -611,7 +611,7 @@ namespace sqlite_orm {
             }
 
             backup_t make_backup_to(const std::string& filename) {
-                auto holder = std::make_unique<connection_holder>(filename, nullptr);
+                auto holder = std::make_unique<connection_holder>(filename, nullptr, connection_control{});
                 connection_ref conRef{*holder};
                 return {conRef, "main", this->get_connection(), "main", std::move(holder)};
             }
@@ -621,7 +621,7 @@ namespace sqlite_orm {
             }
 
             backup_t make_backup_from(const std::string& filename) {
-                auto holder = std::make_unique<connection_holder>(filename, nullptr);
+                auto holder = std::make_unique<connection_holder>(filename, nullptr, connection_control{});
                 connection_ref conRef{*holder};
                 return {this->get_connection(), "main", conRef, "main", std::move(holder)};
             }
@@ -642,6 +642,28 @@ namespace sqlite_orm {
                 return this->connection->retain_count() > 0;
             }
 
+            /**
+             * Return the name of the VFS object used by the database connection.
+             */
+            const std::string& vfs_name() const {
+                return this->connection->vfs_name;
+            }
+
+            /**
+             * Return the current open_mode for this storage object. 
+             */
+            db_open_mode open_mode() const {
+                return this->connection->open_mode;
+            }
+
+            /**
+             * Return true if this database object is opened in a readonly state. 
+             */
+            bool db_readonly() {
+                auto con = this->get_connection();
+                return static_cast<bool>(sqlite3_db_readonly(con.get(), "main"));
+            }
+
             /*
              * returning false when there is a transaction in place
              * otherwise true; function is not const because it has to call get_connection()
@@ -674,7 +696,8 @@ namespace sqlite_orm {
                 inMemory(filename.empty() || filename == ":memory:"), isOpenedForever{connectionCtrl.open_forever},
                 connection(std::make_unique<connection_holder>(
                     std::move(filename),
-                    std::bind(&storage_base::on_open_internal, this, std::placeholders::_1))),
+                    std::bind(&storage_base::on_open_internal, this, std::placeholders::_1),
+                    connectionCtrl)),
                 cachedForeignKeysCount(foreignKeysCount) {
                 if (this->inMemory) {
                     this->connection->retain();
diff --git a/dev/storage_options.h b/dev/storage_options.h
@@ -30,6 +30,8 @@ SQLITE_ORM_EXPORT namespace sqlite_orm {
         /// Whether to open the database once and for all.
         /// Required if using a 'storage' instance from multiple threads.
         bool open_forever = false;
+        std::string vfs_name{default_vfs_name};
+        db_open_mode open_mode = db_open_mode::default_;
 
         using storage_opt_tag = int;
     };
diff --git a/dev/vfs_name.h b/dev/vfs_name.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "serialize_result_type.h"
+
+SQLITE_ORM_EXPORT namespace sqlite_orm {
+
+#ifdef SQLITE_ORM_UNIX
+    SQLITE_ORM_INLINE_VAR constexpr internal::string_constant_type unix_vfs_name = "unix";
+    SQLITE_ORM_INLINE_VAR constexpr internal::string_constant_type unix_posix_vfs_name = unix_vfs_name;
+    SQLITE_ORM_INLINE_VAR constexpr internal::string_constant_type unix_dotfile_vfs_name = "unix-dotfile";
+#ifdef SQLITE_ORM_APPLE
+    SQLITE_ORM_INLINE_VAR constexpr internal::string_constant_type unix_afp_vfs_name = "unix-afp";
+#endif
+    SQLITE_ORM_INLINE_VAR constexpr internal::string_constant_type default_vfs_name = unix_vfs_name;
+#endif
+
+#ifdef SQLITE_ORM_WIN
+    SQLITE_ORM_INLINE_VAR constexpr internal::string_constant_type win32_vfs_name = "win32";
+    SQLITE_ORM_INLINE_VAR constexpr internal::string_constant_type win32_longpath_vfs_name = "win32-longpath";
+
+    SQLITE_ORM_INLINE_VAR constexpr internal::string_constant_type default_vfs_name = win32_vfs_name;
+#endif
+}
diff --git a/include/sqlite_orm/sqlite_orm.h b/include/sqlite_orm/sqlite_orm.h
diff --git a/tests/static_tests/vfs_open_mode_static_tests.cpp b/tests/static_tests/vfs_open_mode_static_tests.cpp
diff --git a/tests/vfs_open_mode_tests.cpp b/tests/vfs_open_mode_tests.cpp

Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,11 @@ namespace sqlite_orm {`
`12`	`12`	`#ifdef SQLITE_ORM_STRING_VIEW_SUPPORTED`
`13`	`13`	`using serialize_result_type = std::string_view;`
`14`	`14`	`using serialize_arg_type = std::string_view;`
	`15`	`+ using string_constant_type = std::string_view;`
`15`	`16`	`#else`
`16`	`17`	`using serialize_result_type = std::string;`
`17`	`18`	`using serialize_arg_type = const std::string&;`
	`19`	`+ using string_constant_type = const char*;`
`18`	`20`	`#endif`
`19`	`21`	`}`
`20`	`22`	`}`