fix: bump cache sqlite dbs to v2 for WAL journal mode change (#24030)

In #23955 we changed the sqlite db
journal mode to WAL. This causes issues when someone is running an old
version of Deno using TRUNCATE and a new version because the two fight
against each other.

Author: dsherret

Cargo.lock

@@ -65,11 +65,11 @@ winres.workspace = true
 [dependencies]
 deno_ast = { workspace = true, features = ["bundler", "cjs", "codegen", "proposal", "react", "sourcemap", "transforms", "typescript", "view", "visit"] }
 deno_cache_dir = { workspace = true }
-deno_config = "=0.16.3"
+deno_config = "=0.16.4"
 deno_core = { workspace = true, features = ["include_js_files_for_snapshotting"] }
 deno_doc = { version = "=0.137.0", features = ["html", "syntect"] }
 deno_emit = "=0.41.0"
-deno_graph = { version = "=0.77.0", features = ["tokio_executor"] }
+deno_graph = { version = "=0.77.2", features = ["tokio_executor"] }
 deno_lint = { version = "=0.58.4", features = ["docs"] }
 deno_lockfile.workspace = true
 deno_npm = "=0.21.0"

cli/Cargo.toml

@@ -14,6 +14,48 @@ use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Arc;
 
+use super::FastInsecureHasher;
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+pub struct CacheDBHash(u64);
+
+impl CacheDBHash {
+  pub fn new(hash: u64) -> Self {
+    Self(hash)
+  }
+
+  pub fn from_source(source: impl std::hash::Hash) -> Self {
+    Self::new(
+      // always write in the deno version just in case
+      // the clearing on deno version change doesn't work
+      FastInsecureHasher::new_deno_versioned()
+        .write_hashable(source)
+        .finish(),
+    )
+  }
+}
+
+impl rusqlite::types::ToSql for CacheDBHash {
+  fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput<'_>> {
+    Ok(rusqlite::types::ToSqlOutput::Owned(
+      // sqlite doesn't support u64, but it does support i64 so store
+      // this value "incorrectly" as i64 then convert back to u64 on read
+      rusqlite::types::Value::Integer(self.0 as i64),
+    ))
+  }
+}
+
+impl rusqlite::types::FromSql for CacheDBHash {
+  fn column_result(
+    value: rusqlite::types::ValueRef,
+  ) -> rusqlite::types::FromSqlResult<Self> {
+    match value {
+      rusqlite::types::ValueRef::Integer(i) => Ok(Self::new(i as u64)),
+      _ => Err(rusqlite::types::FromSqlError::InvalidType),
+    }
+  }
+}
+
 /// What should the cache should do on failure?
 #[derive(Default)]
 pub enum CacheFailure {
@@ -41,21 +83,16 @@ pub struct CacheDBConfiguration {
 impl CacheDBConfiguration {
   fn create_combined_sql(&self) -> String {
     format!(
-      "
-      PRAGMA journal_mode=WAL;
-      PRAGMA synchronous=NORMAL;
-      PRAGMA temp_store=memory;
-      PRAGMA page_size=4096;
-      PRAGMA mmap_size=6000000;
-      PRAGMA optimize;
-
-      CREATE TABLE IF NOT EXISTS info (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-
-      {}
-    ",
+      concat!(
+        "PRAGMA journal_mode=WAL;",
+        "PRAGMA synchronous=NORMAL;",
+        "PRAGMA temp_store=memory;",
+        "PRAGMA page_size=4096;",
+        "PRAGMA mmap_size=6000000;",
+        "PRAGMA optimize;",
+        "CREATE TABLE IF NOT EXISTS info (key TEXT PRIMARY KEY, value TEXT NOT NULL);",
+        "{}",
+      ),
       self.table_initializer
     )
   }
@@ -520,4 +557,32 @@ mod tests {
     })
     .expect_err("Should have failed");
   }
+
+  #[test]
+  fn cache_db_hash_max_u64_value() {
+    assert_same_serialize_deserialize(CacheDBHash::new(u64::MAX));
+    assert_same_serialize_deserialize(CacheDBHash::new(u64::MAX - 1));
+    assert_same_serialize_deserialize(CacheDBHash::new(u64::MIN));
+    assert_same_serialize_deserialize(CacheDBHash::new(u64::MIN + 1));
+  }
+
+  fn assert_same_serialize_deserialize(original_hash: CacheDBHash) {
+    use rusqlite::types::FromSql;
+    use rusqlite::types::ValueRef;
+    use rusqlite::ToSql;
+
+    let value = original_hash.to_sql().unwrap();
+    match value {
+      rusqlite::types::ToSqlOutput::Owned(rusqlite::types::Value::Integer(
+        value,
+      )) => {
+        let value_ref = ValueRef::Integer(value);
+        assert_eq!(
+          original_hash,
+          CacheDBHash::column_result(value_ref).unwrap()
+        );
+      }
+      _ => unreachable!(),
+    }
+  }
 }

cli/cache/cache_db.rs

@@ -2,20 +2,21 @@
 
 use super::cache_db::CacheDB;
 use super::cache_db::CacheDBConfiguration;
+use super::cache_db::CacheDBHash;
 use super::cache_db::CacheFailure;
 use deno_ast::ModuleSpecifier;
 use deno_core::error::AnyError;
 use deno_runtime::deno_webstorage::rusqlite::params;
 
 pub static TYPE_CHECK_CACHE_DB: CacheDBConfiguration = CacheDBConfiguration {
   table_initializer: concat!(
-    "CREATE TABLE IF NOT EXISTS checkcache (
-      check_hash TEXT PRIMARY KEY
-    );",
-    "CREATE TABLE IF NOT EXISTS tsbuildinfo (
-      specifier TEXT PRIMARY KEY,
-      text TEXT NOT NULL
-    );",
+    "CREATE TABLE IF NOT EXISTS checkcache (",
+    "check_hash INT PRIMARY KEY",
+    ");",
+    "CREATE TABLE IF NOT EXISTS tsbuildinfo (",
+    "specifier TEXT PRIMARY KEY,",
+    "text TEXT NOT NULL",
+    ");",
   ),
   on_version_change: concat!(
     "DELETE FROM checkcache;",
@@ -37,7 +38,7 @@ impl TypeCheckCache {
     Self(db)
   }
 
-  pub fn has_check_hash(&self, hash: u64) -> bool {
+  pub fn has_check_hash(&self, hash: CacheDBHash) -> bool {
     match self.hash_check_hash_result(hash) {
       Ok(val) => val,
       Err(err) => {
@@ -52,14 +53,17 @@ impl TypeCheckCache {
     }
   }
 
-  fn hash_check_hash_result(&self, hash: u64) -> Result<bool, AnyError> {
+  fn hash_check_hash_result(
+    &self,
+    hash: CacheDBHash,
+  ) -> Result<bool, AnyError> {
     self.0.exists(
       "SELECT * FROM checkcache WHERE check_hash=?1 LIMIT 1",
-      params![hash.to_string()],
+      params![hash],
     )
   }
 
-  pub fn add_check_hash(&self, check_hash: u64) {
+  pub fn add_check_hash(&self, check_hash: CacheDBHash) {
     if let Err(err) = self.add_check_hash_result(check_hash) {
       if cfg!(debug_assertions) {
         panic!("Error saving check hash: {err}");
@@ -69,13 +73,16 @@ impl TypeCheckCache {
     }
   }
 
-  fn add_check_hash_result(&self, check_hash: u64) -> Result<(), AnyError> {
+  fn add_check_hash_result(
+    &self,
+    check_hash: CacheDBHash,
+  ) -> Result<(), AnyError> {
     let sql = "
     INSERT OR REPLACE INTO
       checkcache (check_hash)
     VALUES
       (?1)";
-    self.0.execute(sql, params![&check_hash.to_string(),])?;
+    self.0.execute(sql, params![check_hash])?;
     Ok(())
   }
 
@@ -123,10 +130,10 @@ mod test {
     let conn = CacheDB::in_memory(&TYPE_CHECK_CACHE_DB, "1.0.0");
     let cache = TypeCheckCache::new(conn);
 
-    assert!(!cache.has_check_hash(1));
-    cache.add_check_hash(1);
-    assert!(cache.has_check_hash(1));
-    assert!(!cache.has_check_hash(2));
+    assert!(!cache.has_check_hash(CacheDBHash::new(1)));
+    cache.add_check_hash(CacheDBHash::new(1));
+    assert!(cache.has_check_hash(CacheDBHash::new(1)));
+    assert!(!cache.has_check_hash(CacheDBHash::new(2)));
 
     let specifier1 = ModuleSpecifier::parse("file:///test.json").unwrap();
     assert_eq!(cache.get_tsbuildinfo(&specifier1), None);
@@ -137,9 +144,9 @@ mod test {
     let conn = cache.0.recreate_with_version("2.0.0");
     let cache = TypeCheckCache::new(conn);
 
-    assert!(!cache.has_check_hash(1));
-    cache.add_check_hash(1);
-    assert!(cache.has_check_hash(1));
+    assert!(!cache.has_check_hash(CacheDBHash::new(1)));
+    cache.add_check_hash(CacheDBHash::new(1));
+    assert!(cache.has_check_hash(CacheDBHash::new(1)));
     assert_eq!(cache.get_tsbuildinfo(&specifier1), None);
     cache.set_tsbuildinfo(&specifier1, "test");
     assert_eq!(cache.get_tsbuildinfo(&specifier1), Some("test".to_string()));
@@ -148,13 +155,13 @@ mod test {
     let conn = cache.0.recreate_with_version("2.0.0");
     let cache = TypeCheckCache::new(conn);
 
-    assert!(cache.has_check_hash(1));
-    assert!(!cache.has_check_hash(2));
+    assert!(cache.has_check_hash(CacheDBHash::new(1)));
+    assert!(!cache.has_check_hash(CacheDBHash::new(2)));
     assert_eq!(cache.get_tsbuildinfo(&specifier1), Some("test".to_string()));
 
     // adding when already exists should not cause issue
-    cache.add_check_hash(1);
-    assert!(cache.has_check_hash(1));
+    cache.add_check_hash(CacheDBHash::new(1));
+    assert!(cache.has_check_hash(CacheDBHash::new(1)));
     cache.set_tsbuildinfo(&specifier1, "other");
     assert_eq!(
       cache.get_tsbuildinfo(&specifier1),