diff --git a/Cargo.lock b/Cargo.lock
index 23b2c8334d7ccc9c87f4fee4e2e39db1fbbc4377..6640037f3d83ebd22f89b9c6a8b726686c5643e0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1603,6 +1603,7 @@ dependencies = [
  "collections",
  "gpui",
  "lazy_static",
+ "log",
  "parking_lot 0.11.2",
  "rusqlite",
  "rusqlite_migration",
diff --git a/crates/auto_update/src/auto_update.rs b/crates/auto_update/src/auto_update.rs
index d32835547c6c1ba5903eb9251fa776d5a7bc5544..da3d35a2b8f033706f646fb7b89c197fe91be1ea 100644
--- a/crates/auto_update/src/auto_update.rs
+++ b/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()) })
     }
 }
diff --git a/crates/db/Cargo.toml b/crates/db/Cargo.toml
index 22b4ed1a0d91cce4ba18004280eafaa9e3c8b6f7..a2efe1326125a24110d840ad8d7bf84c59363f43 100644
--- a/crates/db/Cargo.toml
+++ b/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"] }
diff --git a/crates/db/src/db.rs b/crates/db/src/db.rs
index 46c8a24fcdc913378d9a433ff9221429c9604f88..dcef0d659ab8957b56934cf0e02869f8f256b5f6 100644
--- a/crates/db/src/db.rs
+++ b/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,
+        }
+    }
 }
diff --git a/crates/zed/src/main.rs b/crates/zed/src/main.rs
index a921bc2680271f195aa985b751fc98f45df0a9e9..55cb203ee720d1d82b547a527df739316a6cb3ea 100644
--- a/crates/zed/src/main.rs
+++ b/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);
diff --git a/crates/zed/src/paths.rs b/crates/zed/src/paths.rs
index d6d99288c771f5260d5cd452fc97a04f15c87969..81ecc5be8a102f4c5573d90b128fd63042f766a7 100644
--- a/crates/zed/src/paths.rs
+++ b/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");