Use order-preserving map to set pragmas for an initial sqlite statement

Author: ghassmo

sqlx-core/Cargo.toml

@@ -160,3 +160,4 @@ stringprep = "0.1.2"
 bstr = { version = "0.2.14", default-features = false, features = ["std"], optional = true }
 git2 = { version = "0.13.12", default-features = false, optional = true }
 hashlink = "0.7.0"
+indexmap = "1.7.0"

sqlx-core/src/sqlite/options/connect.rs

@@ -18,29 +18,10 @@ impl ConnectOptions for SqliteConnectOptions {
             let mut conn = establish(self).await?;
 
             // send an initial sql statement comprised of options
-
-            // page_size must be set before any other action on the database.
-            let page_size_opt = format!("PRAGMA page_size = {};", self.page_size);
-            conn.execute(&*page_size_opt).await?;
-
-            // apply custom initial_options
-            if let Some(stmt) = self.initial_options {
-                conn.execute(&*stmt).await?;
+            for (key, value) in self.pragmas.iter() {
+                conn.execute(&*format!("PRAGMA {} = {};", key, value)).await?;
             }
 
-            // Note that locking_mode should be set before journal_mode; see
-            // https://www.sqlite.org/wal.html#use_of_wal_without_shared_memory .
-            let init = format!(
-                "PRAGMA locking_mode = {}; PRAGMA journal_mode = {}; PRAGMA foreign_keys = {}; PRAGMA synchronous = {}; PRAGMA auto_vacuum = {}",
-                self.locking_mode.as_str(),
-                self.journal_mode.as_str(),
-                if self.foreign_keys { "ON" } else { "OFF" },
-                self.synchronous.as_str(),
-                self.auto_vacuum.as_str(),
-            );
-
-            conn.execute(&*init).await?;
-
             Ok(conn)
         })
     }

sqlx-core/src/sqlite/options/mod.rs

@@ -14,6 +14,8 @@ pub use locking_mode::SqliteLockingMode;
 use std::{borrow::Cow, time::Duration};
 pub use synchronous::SqliteSynchronous;
 
+use indexmap::IndexMap;
+
 /// Options and flags which can be used to configure a SQLite connection.
 ///
 /// A value of `SqliteConnectOptions` can be parsed from a connection URI,
@@ -53,17 +55,11 @@ pub struct SqliteConnectOptions {
     pub(crate) in_memory: bool,
     pub(crate) read_only: bool,
     pub(crate) create_if_missing: bool,
-    pub(crate) journal_mode: SqliteJournalMode,
-    pub(crate) locking_mode: SqliteLockingMode,
-    pub(crate) foreign_keys: bool,
     pub(crate) shared_cache: bool,
     pub(crate) statement_cache_capacity: usize,
     pub(crate) busy_timeout: Duration,
     pub(crate) log_settings: LogSettings,
-    pub(crate) synchronous: SqliteSynchronous,
-    pub(crate) auto_vacuum: SqliteAutoVacuum,
-    pub(crate) initial_options: Option<&'static str>,
-    pub(crate) page_size: u32,
+    pub(crate) pragmas: IndexMap<String, String>,
 }
 
 impl Default for SqliteConnectOptions {
@@ -74,22 +70,43 @@ impl Default for SqliteConnectOptions {
 
 impl SqliteConnectOptions {
     pub fn new() -> Self {
+        // set default pragmas
+        let mut pragmas = IndexMap::new();
+
+        let locking_mode: SqliteLockingMode = Default::default();
+        let auto_vacuum: SqliteAutoVacuum = Default::default();
+
+        // page_size must be set before any other action on the database.
+        pragmas.insert("page_size".into(), 4096.to_string());
+        
+        // Note that locking_mode should be set before journal_mode; see
+        // https://www.sqlite.org/wal.html#use_of_wal_without_shared_memory .
+        pragmas.insert("locking_mode".into(), locking_mode.as_str().into());
+
+        pragmas.insert(
+            "journal_mode".into(),
+            SqliteJournalMode::Wal.as_str().into(),
+        );
+
+        pragmas.insert("foreign_keys".into(), "ON".into());
+
+        pragmas.insert(
+            "synchronous".into(),
+            SqliteSynchronous::Full.as_str().into(),
+        );
+
+        pragmas.insert("auto_vacuum".into(), auto_vacuum.as_str().into());
+
         Self {
             filename: Cow::Borrowed(Path::new(":memory:")),
             in_memory: false,
             read_only: false,
             create_if_missing: false,
-            foreign_keys: true,
             shared_cache: false,
             statement_cache_capacity: 100,
-            journal_mode: SqliteJournalMode::Wal,
-            locking_mode: Default::default(),
             busy_timeout: Duration::from_secs(5),
             log_settings: Default::default(),
-            synchronous: SqliteSynchronous::Full,
-            auto_vacuum: Default::default(),
-            initial_options: None,
-            page_size: 4096,
+            pragmas,
         }
     }
 
@@ -103,7 +120,10 @@ impl SqliteConnectOptions {
     ///
     /// By default, this is enabled.
     pub fn foreign_keys(mut self, on: bool) -> Self {
-        self.foreign_keys = on;
+        self.pragmas.insert(
+            "foreign_keys".into(),
+            (if on { "ON" } else { "OFF" }).into(),
+        );
         self
     }
 
@@ -120,15 +140,17 @@ impl SqliteConnectOptions {
     /// The default journal mode is WAL. For most use cases this can be significantly faster but
     /// there are [disadvantages](https://www.sqlite.org/wal.html).
     pub fn journal_mode(mut self, mode: SqliteJournalMode) -> Self {
-        self.journal_mode = mode;
+        self.pragmas
+            .insert("journal_mode".into(), mode.as_str().into());
         self
     }
 
     /// Sets the [locking mode](https://www.sqlite.org/pragma.html#pragma_locking_mode) for the database connection.
     ///
     /// The default locking mode is NORMAL.
     pub fn locking_mode(mut self, mode: SqliteLockingMode) -> Self {
-        self.locking_mode = mode;
+        self.pragmas
+            .insert("locking_mode".into(), mode.as_str().into());
         self
     }
 
@@ -173,31 +195,31 @@ impl SqliteConnectOptions {
     /// The default synchronous settings is FULL. However, if durability is not a concern,
     /// then NORMAL is normally all one needs in WAL mode.
     pub fn synchronous(mut self, synchronous: SqliteSynchronous) -> Self {
-        self.synchronous = synchronous;
+        self.pragmas
+            .insert("synchronous".into(), synchronous.as_str().into());
         self
     }
 
     /// Sets the [auto_vacuum](https://www.sqlite.org/pragma.html#pragma_auto_vacuum) setting for the database connection.
     ///
     /// The default auto_vacuum setting is NONE.
     pub fn auto_vacuum(mut self, auto_vacuum: SqliteAutoVacuum) -> Self {
-        self.auto_vacuum = auto_vacuum;
+        self.pragmas
+            .insert("auto_vacuum".into(), auto_vacuum.as_str().into());
         self
     }
 
-    /// Sets custom initial settings for the database connection.
-    ///
-    /// The default initial_options is NONE.
-    pub fn initial_options(mut self, initial_options: &'static str) -> Self {
-        self.initial_options  = Some(initial_options);
+    /// Sets custom initial pragmas for the database connection.
+    pub fn pragma(mut self, key: &str, value: &str) -> Self {
+        self.pragmas.insert(key.into(), value.into());
         self
     }
 
     /// Sets the [page_size](https://www.sqlite.org/pragma.html#pragma_page_size) setting for the database connection.
     ///
     /// The default page_size setting is 4096.
     pub fn page_size(mut self, page_size: u32) -> Self {
-        self.page_size = page_size;
+        self.pragmas.insert("page_size".into(), page_size.to_string());
         self
     }
 }