Cache cl for pks in map

Signed-off-by: Somtochi Onyekwere <[email protected]>

Author: somtochiama

core/rs/bundle/Cargo.toml

@@ -16,6 +16,7 @@ crate-type = ["rlib"]
 crsql_fractindex_core = {path="../fractindex-core"}
 crsql_core = { path="../core" }
 sqlite_nostd = { path="../sqlite-rs-embedded/sqlite_nostd" }
+libc-print = "*"
 
 [profile.dev]
 panic = "abort"

core/rs/bundle/src/lib.rs

@@ -11,6 +11,8 @@ use crsql_core::sqlite3_crsqlcore_init;
 #[cfg(feature = "test")]
 pub use crsql_core::test_exports;
 use crsql_fractindex_core::sqlite3_crsqlfractionalindex_init;
+#[cfg(feature = "test")]
+use libc_print::std_name::println;
 use sqlite_nostd as sqlite;
 use sqlite_nostd::SQLite3Allocator;
 
@@ -21,11 +23,20 @@ static ALLOCATOR: SQLite3Allocator = SQLite3Allocator {};
 
 // This must be our panic handler for WASM builds. For simplicity, we make it our panic handler for
 // all builds. Abort is also more portable than unwind, enabling us to go to more embedded use cases.
+#[cfg(not(feature = "test"))]
 #[panic_handler]
 fn panic(_info: &PanicInfo) -> ! {
     core::intrinsics::abort()
 }
 
+// Print panic info for tests
+#[cfg(feature = "test")]
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    println!("PANIC!: {}", info);
+    core::intrinsics::abort();
+}
+
 #[cfg(not(target_family = "wasm"))]
 #[lang = "eh_personality"]
 extern "C" fn eh_personality() {}

core/rs/bundle_static/Cargo.lock

@@ -74,6 +74,7 @@ pub struct crsql_ExtData {
     pub mergeEqualValues: ::core::ffi::c_int,
     pub timestamp: ::core::ffi::c_ulonglong,
     pub ordinalMap: *mut ::core::ffi::c_void,
+    pub clCache: *mut ::core::ffi::c_void,
 }
 
 #[repr(C)]
@@ -271,7 +272,7 @@ fn bindgen_test_layout_crsql_ExtData() {
     let ptr = UNINIT.as_ptr();
     assert_eq!(
         ::core::mem::size_of::<crsql_ExtData>(),
-        168usize,
+        176usize,
         concat!("Size of: ", stringify!(crsql_ExtData))
     );
     assert_eq!(
@@ -511,4 +512,14 @@ fn bindgen_test_layout_crsql_ExtData() {
             stringify!(ordinalMap)
         )
     );
+    assert_eq!(
+        unsafe { ::core::ptr::addr_of!((*ptr).clCache) as usize - ptr as usize },
+        168usize,
+        concat!(
+            "Offset of field: ",
+            stringify!(crsql_ExtData),
+            "::",
+            stringify!(clCache)
+        )
+    );
 }

core/rs/core/src/c.rs

@@ -586,6 +586,19 @@ pub extern "C" fn crsql_changes_rollback_to(vtab: *mut sqlite::vtab, _: c_int) -
             (*(*tab).pExtData).ordinalMap as *mut BTreeMap<Vec<u8>, i64>,
         ))
     };
+
+    let mut cl_cache = unsafe {
+        mem::ManuallyDrop::new(Box::from_raw(
+            (*(*tab).pExtData).clCache as *mut BTreeMap<String, BTreeMap<i64, i64>>,
+        ))
+    };
+
+    for (_, map) in cl_cache.iter_mut() {
+        if !map.is_empty() {
+            map.clear(); 
+        }
+    }
+    
     ordinals.clear();
     ResultCode::OK as c_int
 }

core/rs/core/src/changes_vtab.rs

@@ -1,6 +1,8 @@
 use alloc::boxed::Box;
+use alloc::collections::BTreeMap;
 use alloc::ffi::CString;
 use alloc::format;
+use alloc::string::String;
 use alloc::vec::Vec;
 use core::ffi::{c_char, c_int};
 use core::mem;
@@ -466,6 +468,11 @@ unsafe fn merge_insert(
     let tbl_infos = mem::ManuallyDrop::new(Box::from_raw(
         (*(*tab).pExtData).tableInfos as *mut Vec<TableInfo>,
     ));
+
+    let mut cl_cache = mem::ManuallyDrop::new(Box::from_raw(
+        (*(*tab).pExtData).clCache as *mut BTreeMap<String, BTreeMap<i64, i64>>,
+    ));
+
     // TODO: will this work given `insert_tbl` is null termed?
     let tbl_info_index = tbl_infos.iter().position(|x| x.tbl_name == insert_tbl);
 
@@ -487,7 +494,7 @@ unsafe fn merge_insert(
     // We'll need the key for all later operations.
     let key = tbl_info.get_or_create_key(db, &unpacked_pks)?;
 
-    let local_cl = get_local_cl(db, &tbl_info, key)?;
+    let local_cl = get_pk_cl(db, &mut cl_cache, &tbl_info, key)?;
 
     // We can ignore all updates from older causal lengths.
     // They won't win at anything.
@@ -593,8 +600,6 @@ unsafe fn merge_insert(
                 *rowid = slab_rowid(tbl_info_index as i32, inner_rowid);
             }
             return Ok(ResultCode::OK);
-            
-            
         }
 
         // we got a causal length which would resurrect the row.
@@ -712,7 +717,40 @@ unsafe fn merge_insert(
             *errmsg = err.into_raw();
             return Err(rc);
         }
+
+        // a bigger cl always wins
+        if insert_cl > local_cl {
+            match cl_cache.get_mut(&tbl_info.tbl_name) {
+                Some(x) => {
+                    x.insert(key, insert_cl);
+                }
+                None => {
+                    let mut new_map = BTreeMap::new();
+                    new_map.insert(key, insert_cl);
+                    cl_cache.insert(tbl_info.tbl_name.clone(), new_map);
+                }
+            }
+        }
     }
 
     res
 }
+
+unsafe fn get_pk_cl(
+    db: *mut sqlite3,
+    cl_cache: &mut BTreeMap<String, BTreeMap<i64, i64>>,
+    tbl_info: &TableInfo,
+    key: sqlite::int64,
+) -> Result<sqlite::int64, ResultCode> {
+    match cl_cache.get(&tbl_info.tbl_name).and_then(|x| x.get(&key)) {
+        Some(cl) => Ok(*cl),
+        None => {
+            let cl = get_local_cl(db, tbl_info, key)?;
+            cl_cache
+                .entry(tbl_info.tbl_name.clone())
+                .or_default()
+                .insert(key, cl);
+            Ok(cl)
+        }
+    }
+}

core/rs/core/src/changes_vtab_write.rs

@@ -1,4 +1,4 @@
-use alloc::{boxed::Box, collections::BTreeMap, vec::Vec};
+use alloc::{boxed::Box, collections::BTreeMap, string::String, vec::Vec};
 use core::{
     ffi::{c_int, c_void},
     mem,
@@ -37,5 +37,17 @@ pub unsafe fn commit_or_rollback_reset(ext_data: *mut crsql_ExtData) {
     let mut ordinals: mem::ManuallyDrop<Box<BTreeMap<Vec<u8>, i64>>> = mem::ManuallyDrop::new(
         Box::from_raw((*ext_data).ordinalMap as *mut BTreeMap<Vec<u8>, i64>),
     );
+
+    let mut cl_cache = unsafe {
+        mem::ManuallyDrop::new(Box::from_raw(
+            (*ext_data).clCache as *mut BTreeMap<String, BTreeMap<i64, i64>>,
+        ))
+    };
+
+    for (_, map) in cl_cache.iter_mut() {
+        if !map.is_empty() {
+            map.clear();
+        }
+    }
     ordinals.clear();
 }

core/rs/core/src/commit.rs

@@ -211,6 +211,21 @@ pub extern "C" fn crsql_drop_ordinal_map(ext_data: *mut crsql_ExtData) {
     }
 }
 
+#[no_mangle]
+pub extern "C" fn crsql_init_cl_cache(ext_data: *mut crsql_ExtData) {
+    let map: BTreeMap<String, BTreeMap<i64, i64>> = BTreeMap::new();
+    unsafe { (*ext_data).clCache = Box::into_raw(Box::new(map)) as *mut c_void }
+}
+
+#[no_mangle]
+pub extern "C" fn crsql_drop_cl_cache(ext_data: *mut crsql_ExtData) {
+    unsafe {
+        drop(Box::from_raw(
+            (*ext_data).clCache as *mut BTreeMap<String, BTreeMap<i64, i64>>,
+        ));
+    }
+}
+
 pub fn insert_db_version(
     ext_data: *mut crsql_ExtData,
     insert_site_id: &[u8],

core/rs/core/src/db_version.rs

@@ -49,6 +49,7 @@ mod unpack_columns_vtab;
 mod util;
 
 use alloc::format;
+use alloc::string::String;
 use alloc::string::ToString;
 use alloc::{borrow::Cow, boxed::Box, collections::BTreeMap, vec::Vec};
 use core::ffi::c_char;
@@ -453,19 +454,30 @@ pub extern "C" fn sqlite3_crsqlcore_init(
     }
 
     #[cfg(feature = "test")]
-    let rc = db
-        .create_function_v2(
-            "crsql_cache_site_ordinal",
-            1,
-            sqlite::UTF8 | sqlite::DETERMINISTIC,
-            Some(ext_data as *mut c_void),
-            Some(x_crsql_cache_site_ordinal),
-            None,
-            None,
-            None,
-        )
-        .unwrap_or(ResultCode::ERROR);
-    if rc != ResultCode::OK {
+    if let Err(_) = db.create_function_v2(
+        "crsql_cache_site_ordinal",
+        1,
+        sqlite::UTF8 | sqlite::DETERMINISTIC,
+        Some(ext_data as *mut c_void),
+        Some(x_crsql_cache_site_ordinal),
+        None,
+        None,
+        None,
+    ) {
+        unsafe { crsql_freeExtData(ext_data) };
+        return null_mut();
+    }
+
+    if let Err(_) = db.create_function_v2(
+        "crsql_cache_pk_cl",
+        2,
+        sqlite::UTF8 | sqlite::DETERMINISTIC,
+        Some(ext_data as *mut c_void),
+        Some(x_crsql_cache_pk_cl),
+        None,
+        None,
+        None,
+    ) {
         unsafe { crsql_freeExtData(ext_data) };
         return null_mut();
     }
@@ -975,6 +987,39 @@ unsafe extern "C" fn x_crsql_cache_site_ordinal(
     sqlite::result_int64(ctx, res);
 }
 
+/**
+ * Get the pk cl cached in the ext data for the current transaction.
+ * only used for test to inspect the cl cache.
+ */
+unsafe extern "C" fn x_crsql_cache_pk_cl(
+    ctx: *mut sqlite::context,
+    argc: i32,
+    argv: *mut *mut sqlite::value,
+) {
+    if argc < 2 {
+        ctx.result_error(
+            "Wrong number of args provided to crsql_cache_pk_cl. Provide the table name and pk key.",
+        );
+        return;
+    }
+
+    let ext_data = ctx.user_data() as *mut c::crsql_ExtData;
+    let args = sqlite::args!(argc, argv);
+    let table_name = args[0].text();
+    let pk_key = args[1].int64();
+
+    let cl_cache = mem::ManuallyDrop::new(Box::from_raw(
+        (*ext_data).clCache as *mut BTreeMap<String, BTreeMap<i64, i64>>,
+    ));
+
+    let table_map = cl_cache.get(table_name);
+    let cl = table_map
+        .and_then(|x| x.get(&pk_key))
+        .cloned()
+        .unwrap_or(-1);
+    sqlite::result_int64(ctx, cl);
+}
+
 /**
  * Return the timestamp for the current transaction.
  */

core/rs/core/src/lib.rs

@@ -1,6 +1,8 @@
 use alloc::string::String;
 use alloc::string::ToString;
+use alloc::{boxed::Box, collections::BTreeMap};
 use core::ffi::c_int;
+use core::mem;
 use sqlite::sqlite3;
 use sqlite::value;
 use sqlite::Context;
@@ -10,6 +12,7 @@ use sqlite_nostd as sqlite;
 use crate::{c::crsql_ExtData, tableinfo::TableInfo};
 
 use super::bump_seq;
+use super::mark_locally_deleted;
 use super::trigger_fn_preamble;
 
 /**
@@ -47,19 +50,7 @@ fn after_delete(
         .get_or_create_key_via_raw_values(db, pks_old)
         .map_err(|_| "failed getting or creating lookaside key")?;
 
-    let mark_locally_deleted_stmt_ref = tbl_info
-        .get_mark_locally_deleted_stmt(db)
-        .map_err(|_e| "failed to get mark_locally_deleted_stmt")?;
-    let mark_locally_deleted_stmt = mark_locally_deleted_stmt_ref
-        .as_ref()
-        .ok_or("Failed to deref sentinel stmt")?;
-    mark_locally_deleted_stmt
-        .bind_int64(1, key)
-        .and_then(|_| mark_locally_deleted_stmt.bind_int64(2, db_version))
-        .and_then(|_| mark_locally_deleted_stmt.bind_int(3, seq))
-        .and_then(|_| mark_locally_deleted_stmt.bind_text(4, &ts, sqlite::Destructor::STATIC))
-        .map_err(|_| "failed binding to mark locally deleted stmt")?;
-    super::step_trigger_stmt(mark_locally_deleted_stmt)?;
+    let cl = mark_locally_deleted(db, tbl_info, key, db_version, seq, &ts)?;
 
     // now actually delete the row metadata
     let drop_clocks_stmt_ref = tbl_info
@@ -72,5 +63,17 @@ fn after_delete(
     drop_clocks_stmt
         .bind_int64(1, key)
         .map_err(|_e| "failed to bind pks to drop_clocks_stmt")?;
-    super::step_trigger_stmt(drop_clocks_stmt)
+    super::step_trigger_stmt(drop_clocks_stmt)?;
+
+    let mut cl_cache = unsafe {
+        mem::ManuallyDrop::new(Box::from_raw(
+            (*ext_data).clCache as *mut BTreeMap<String, BTreeMap<i64, i64>>,
+        ))
+    };
+    cl_cache
+        .entry(tbl_info.tbl_name.clone())
+        .or_default()
+        .insert(key, cl);
+
+    Ok(ResultCode::OK)
 }