Get rusqlite more shippable

K Simmons created 3 years ago

Change summary

Cargo.lock                            |  1 
crates/auto_update/src/auto_update.rs |  9 ++--
crates/db/Cargo.toml                  |  3 +
crates/db/src/db.rs                   | 55 ++++++++++++++++++++--------
crates/zed/src/main.rs                |  2 
crates/zed/src/paths.rs               |  2 
6 files changed, 47 insertions(+), 25 deletions(-)

Detailed changes

Cargo.lock

@@ -1603,6 +1603,7 @@ dependencies = [
  "collections",
  "gpui",
  "lazy_static",
+ "log",
  "parking_lot 0.11.2",
  "rusqlite",
  "rusqlite_migration",

crates/auto_update/src/auto_update.rs

@@ -283,9 +283,9 @@ impl AutoUpdater {
         let db = self.db.clone();
         cx.background().spawn(async move {
             if should_show {
-                db.write([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY, "")])?;
+                db.write_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY, "")?;
             } else {
-                db.delete([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)])?;
+                db.delete_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?;
             }
             Ok(())
         })
@@ -293,8 +293,7 @@ impl AutoUpdater {
 
     fn should_show_update_notification(&self, cx: &AppContext) -> Task<Result<bool>> {
         let db = self.db.clone();
-        cx.background().spawn(async move {
-            Ok(db.read([(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)])?[0].is_some())
-        })
+        cx.background()
+            .spawn(async move { Ok(db.read_kvp(SHOULD_SHOW_UPDATE_NOTIFICATION_KEY)?.is_some()) })
     }
 }

crates/db/Cargo.toml

@@ -14,10 +14,11 @@ test-support = []
 collections = { path = "../collections" }
 anyhow = "1.0.57"
 async-trait = "0.1"
+lazy_static = "1.4.0"
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 parking_lot = "0.11.1"
 rusqlite = { version = "0.28.0", features = ["bundled", "serde_json"] }
 rusqlite_migration = "1.0.0"
-lazy_static = "1.4.0"
 
 [dev-dependencies]
 gpui = { path = "../gpui", features = ["test-support"] }

crates/db/src/db.rs

@@ -1,19 +1,22 @@
-mod items;
 mod kvp;
 mod migrations;
 
+use std::path::Path;
+use std::sync::Arc;
+
 use anyhow::Result;
-use migrations::MIGRATIONS;
+use log::error;
 use parking_lot::Mutex;
 use rusqlite::Connection;
-use std::path::Path;
-use std::sync::Arc;
 
-pub use kvp::*;
+use migrations::MIGRATIONS;
 
-pub struct Db {
-    connection: Mutex<Connection>,
-    in_memory: bool,
+pub enum Db {
+    Real {
+        connection: Mutex<Connection>,
+        in_memory: bool,
+    },
+    Null,
 }
 
 // To make a migration:
@@ -23,25 +26,43 @@ pub struct Db {
 impl Db {
     /// Open or create a database at the given file path. Falls back to in memory database if the
     /// database at the given path is corrupted
-    pub fn open(path: &Path) -> Result<Arc<Self>> {
-        let conn = Connection::open(path)?;
-
-        Self::initialize(conn, false).or_else(|_| Self::open_in_memory())
+    pub fn open(path: &Path) -> Arc<Self> {
+        Connection::open(path)
+            .map_err(Into::into)
+            .and_then(|connection| Self::initialize(connection, false))
+            .unwrap_or_else(|e| {
+                error!(
+                    "Connecting to db failed. Falling back to in memory db. {}",
+                    e
+                );
+                Self::open_in_memory()
+            })
     }
 
     /// Open a in memory database for testing and as a fallback.
-    pub fn open_in_memory() -> Result<Arc<Self>> {
-        let conn = Connection::open_in_memory()?;
-
-        Self::initialize(conn, true)
+    pub fn open_in_memory() -> Arc<Self> {
+        Connection::open_in_memory()
+            .map_err(Into::into)
+            .and_then(|connection| Self::initialize(connection, true))
+            .unwrap_or_else(|e| {
+                error!("Connecting to in memory db failed. Reverting to null db. {}");
+                Arc::new(Self::Null)
+            })
     }
 
     fn initialize(mut conn: Connection, in_memory: bool) -> Result<Arc<Self>> {
         MIGRATIONS.to_latest(&mut conn)?;
 
-        Ok(Arc::new(Self {
+        Ok(Arc::new(Self::Real {
             connection: Mutex::new(conn),
             in_memory,
         }))
     }
+
+    fn persisting(&self) -> bool {
+        match self {
+            Db::Real { in_memory, .. } => *in_memory,
+            _ => false,
+        }
+    }
 }

crates/zed/src/main.rs

@@ -55,7 +55,7 @@ fn main() {
     let db = app.background().spawn(async move {
         project::Db::open(&*zed::paths::DB)
             .log_err()
-            .unwrap_or_else(project::Db::null)
+            .unwrap_or_else(project::Db::open_in_memory())
     });
 
     load_embedded_fonts(&app);

crates/zed/src/paths.rs

@@ -6,7 +6,7 @@ lazy_static::lazy_static! {
     pub static ref LOGS_DIR: PathBuf = HOME.join("Library/Logs/Zed");
     pub static ref LANGUAGES_DIR: PathBuf = HOME.join("Library/Application Support/Zed/languages");
     pub static ref DB_DIR: PathBuf = HOME.join("Library/Application Support/Zed/db");
-    pub static ref DB: PathBuf = DB_DIR.join("zed.db");
+    pub static ref DB: PathBuf = DB_DIR.join("zed.sqlite");
     pub static ref SETTINGS: PathBuf = CONFIG_DIR.join("settings.json");
     pub static ref KEYMAP: PathBuf = CONFIG_DIR.join("keymap.json");
     pub static ref LAST_USERNAME: PathBuf = CONFIG_DIR.join("last-username.txt");