khive-db 0.15.0

SQLite storage backend: entities, edges, notes, events, FTS5, sqlite-vec vectors.
Documentation
use super::*;
use std::sync::atomic::{AtomicBool, AtomicUsize};

fn pool(path: &Path, locks: &Path) -> ConnectionPool {
    ConnectionPool::new(PoolConfig {
        path: Some(path.to_path_buf()),
        volume_lock_dir: Some(locks.to_path_buf()),
        write_queue_enabled: Some(false),
        disk_guard_config: Some(EffectiveDiskGuardConfig {
            reserve_bytes: 0,
            guard_deadline_ms: 100,
            ..Default::default()
        }),
        ..PoolConfig::for_test()
    })
    .unwrap()
}

fn count(pool: &ConnectionPool) -> i64 {
    pool.reader()
        .unwrap()
        .conn()
        .query_row("SELECT COUNT(*) FROM pooled_owner_probe", [], |row| {
            row.get(0)
        })
        .unwrap()
}

#[test]
fn delayed_public_writer_checks_capacity_at_autocommit_execution() {
    let dir = tempfile::tempdir().unwrap();
    let mut pool = pool(&dir.path().join("delayed.db"), &dir.path().join("locks"));
    pool.writer()
        .unwrap()
        .autocommit(|conn| {
            conn.execute_batch("CREATE TABLE pooled_owner_probe(value INTEGER)")?;
            Ok(())
        })
        .unwrap();
    let available = Arc::new(AtomicU64::new(101));
    let samples = Arc::new(AtomicUsize::new(0));
    let sampled = Arc::clone(&available);
    let observed = Arc::clone(&samples);
    pool.set_test_write_admission(100, move |_| {
        observed.fetch_add(1, Ordering::SeqCst);
        Ok(sampled.load(Ordering::SeqCst))
    });
    let writer = pool.writer().expect("checkout while capacity is healthy");
    assert_eq!(samples.load(Ordering::SeqCst), 0);
    available.store(100, Ordering::SeqCst);
    let body_ran = AtomicBool::new(false);
    let result = writer.autocommit(|conn| {
        body_ran.store(true, Ordering::SeqCst);
        conn.execute_batch("INSERT INTO pooled_owner_probe VALUES(1)")?;
        Ok(())
    });
    assert!(matches!(result, Err(SqliteError::CapacityFloor { .. })));
    assert!(!body_ran.load(Ordering::SeqCst));
    assert_eq!(count(&pool), 0);
    available.store(101, Ordering::SeqCst);
    pool.writer()
        .unwrap()
        .autocommit(|conn| {
            conn.execute_batch("INSERT INTO pooled_owner_probe VALUES(2)")?;
            Ok(())
        })
        .expect("capacity refusal returned the owner and its lease");
    assert_eq!(samples.load(Ordering::SeqCst), 2);
    assert_eq!(count(&pool), 1);
}

#[test]
fn public_pooled_transaction_samples_after_begin_and_finalizes_below_floor() {
    for fail_body in [false, true] {
        let dir = tempfile::tempdir().unwrap();
        let path = dir.path().join("transaction.db");
        let mut pool = pool(&path, &dir.path().join("locks"));
        pool.writer()
            .unwrap()
            .autocommit(|conn| {
                conn.execute_batch("CREATE TABLE pooled_owner_probe(value INTEGER)")?;
                Ok(())
            })
            .unwrap();
        let available = Arc::new(AtomicU64::new(101));
        let samples = Arc::new(AtomicUsize::new(0));
        let sampled = Arc::clone(&available);
        let observed = Arc::clone(&samples);
        pool.set_test_write_admission(100, move |_| {
            let contender = Connection::open(&path).unwrap();
            contender.busy_timeout(Duration::ZERO).unwrap();
            let error = contender.execute_batch("BEGIN IMMEDIATE").unwrap_err();
            assert!(crate::timeout_sink::is_busy_or_locked(&error));
            observed.fetch_add(1, Ordering::SeqCst);
            Ok(sampled.load(Ordering::SeqCst))
        });
        let writer = pool.try_writer().unwrap();
        assert_eq!(samples.load(Ordering::SeqCst), 0);
        let result = writer.transaction(|conn| {
            conn.execute_batch("INSERT INTO pooled_owner_probe VALUES(1)")?;
            available.store(0, Ordering::SeqCst);
            if fail_body {
                return Err(SqliteError::InvalidData("body failure".into()));
            }
            conn.execute_batch("INSERT INTO pooled_owner_probe VALUES(2)")?;
            Ok(())
        });
        if fail_body {
            assert!(
                matches!(result, Err(SqliteError::InvalidData(message)) if message == "body failure")
            );
        } else {
            result.unwrap();
        }
        assert_eq!(samples.load(Ordering::SeqCst), 1);
        assert_eq!(count(&pool), if fail_body { 0 } else { 2 });
    }
}

#[test]
fn pooled_script_refuses_unfinished_transactions_and_recovers_the_writer() {
    let dir = tempfile::tempdir().unwrap();
    let pool = pool(&dir.path().join("script.db"), &dir.path().join("locks"));
    let result = pool.writer().unwrap().autocommit(|conn| {
        conn.execute_batch(
            "CREATE TABLE pooled_owner_probe(value INTEGER); \
             BEGIN IMMEDIATE; INSERT INTO pooled_owner_probe VALUES(1)",
        )?;
        Ok(())
    });
    assert!(matches!(result, Err(SqliteError::InvalidData(_))));
    assert_eq!(count(&pool), 0);
    pool.writer()
        .unwrap()
        .autocommit(|conn| {
            conn.execute_batch(
                "BEGIN IMMEDIATE; INSERT INTO pooled_owner_probe VALUES(2); COMMIT",
            )?;
            Ok(())
        })
        .unwrap();
    assert_eq!(count(&pool), 1);
}

#[test]
fn public_pooled_owners_preserve_native_full_and_existing_settlement_policy() {
    for transactional in [false, true] {
        let dir = tempfile::tempdir().unwrap();
        let pool = pool(&dir.path().join("full.db"), &dir.path().join("locks"));
        pool.writer()
            .unwrap()
            .autocommit(|conn| {
                conn.execute_batch("CREATE TABLE admission_payload(value BLOB)")?;
                let pages: i64 = conn.query_row("PRAGMA page_count", [], |row| row.get(0))?;
                conn.pragma_update(None, "max_page_count", pages + 1)?;
                Ok(())
            })
            .unwrap();
        let mut observed = None;
        let body = |conn: &Connection| -> Result<(), SqliteError> {
            let result = conn.execute(
                "INSERT INTO admission_payload VALUES (zeroblob(2097152))",
                [],
            );
            observed = Some((
                result
                    .as_ref()
                    .err()
                    .and_then(rusqlite::Error::sqlite_error_code),
                conn.is_autocommit(),
            ));
            result?;
            Ok(())
        };
        let writer = pool.writer().unwrap();
        let error = if transactional {
            writer.transaction(body)
        } else {
            writer.autocommit(body)
        }
        .expect_err("the per-connection page limit must produce native FULL");
        assert_eq!(observed, Some((Some(rusqlite::ErrorCode::DiskFull), true)));
        assert_eq!(
            error.write_failure(),
            Some(khive_storage::error::SqliteWriteFailure {
                stage: khive_storage::error::SqliteWriteStage::Statement,
                primary_code: rusqlite::ffi::SQLITE_FULL,
                extended_code: rusqlite::ffi::SQLITE_FULL,
                // Preserve the existing transaction rollback/escalation
                // policy pinned by pr3423_sqlite_full; #4405 is separate.
                settlement_unknown: transactional,
            })
        );
        if transactional {
            assert!(
                pool.try_writer().is_err(),
                "the existing policy retires this writer"
            );
        } else {
            pool.writer()
                .unwrap()
                .autocommit(|conn| {
                    conn.execute_batch("INSERT INTO admission_payload VALUES(NULL)")?;
                    Ok(())
                })
                .expect("definite autocommit FULL retains a usable owner");
        }
    }
}

#[test]
fn pooled_transaction_unwind_keeps_registry_and_lease_until_native_rollback() {
    use rusqlite::hooks::{AuthAction, AuthContext, Authorization, TransactionOperation};

    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("unwind.db");
    let locks = dir.path().join("locks");
    let pool = pool(&path, &locks);
    pool.writer()
        .unwrap()
        .autocommit(|conn| {
            conn.execute_batch("CREATE TABLE pooled_owner_probe(value INTEGER)")?;
            Ok(())
        })
        .unwrap();
    let identity = VolumeIdentity::resolve(&path).unwrap();
    let lock_path = locks.join(identity.lock_filename());
    let origin = match pool.origin() {
        TxOrigin::Database(identity) => {
            khive_storage::tx_registry::TxOriginFilter::Secondary(identity)
        }
        other => panic!("expected database transaction origin, got {other:?}"),
    };
    let rollback_saw_registry = Arc::new(AtomicBool::new(false));
    let rollback_saw_lease = Arc::new(AtomicBool::new(false));
    let registry = Arc::clone(&rollback_saw_registry);
    let lease = Arc::clone(&rollback_saw_lease);
    let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        pool.writer()
            .unwrap()
            .transaction(|conn| -> Result<(), SqliteError> {
                conn.execute_batch("INSERT INTO pooled_owner_probe VALUES(1)")?;
                conn.authorizer(Some(move |context: AuthContext<'_>| {
                    if matches!(
                        context.action,
                        AuthAction::Transaction {
                            operation: TransactionOperation::Rollback
                        }
                    ) {
                        registry.store(
                            khive_storage::tx_registry::oldest_for(&origin).is_some_and(|span| {
                                span.label.as_deref() == Some("writer_guard_tx")
                            }),
                            Ordering::SeqCst,
                        );
                        let held = std::fs::OpenOptions::new()
                            .read(true)
                            .write(true)
                            .open(&lock_path)
                            .ok()
                            .is_some_and(|file| {
                                matches!(
                                    fs4::FileExt::try_lock(&file),
                                    Err(fs4::TryLockError::WouldBlock)
                                )
                            });
                        lease.store(held, Ordering::SeqCst);
                    }
                    Authorization::Allow
                }))?;
                panic!("callback unwound inside its consuming owner");
            })
    }));
    assert!(panic.is_err());
    assert!(rollback_saw_registry.load(Ordering::SeqCst));
    assert!(rollback_saw_lease.load(Ordering::SeqCst));
    assert_eq!(count(&pool), 0);
    pool.writer()
        .unwrap()
        .transaction(|conn| {
            conn.authorizer(None::<fn(AuthContext<'_>) -> Authorization>)?;
            conn.execute_batch("INSERT INTO pooled_owner_probe VALUES(2)")?;
            Ok(())
        })
        .expect("panic rollback completed before another writer could begin");
    assert_eq!(count(&pool), 1);
}

#[test]
fn public_autocommit_failed_script_preserves_native_error_after_rollback() {
    use khive_storage::error::{SqliteWriteFailure, SqliteWriteStage};
    use rusqlite::hooks::{AuthAction, AuthContext, Authorization, TransactionOperation};

    for standalone in [false, true] {
        let dir = tempfile::tempdir().unwrap();
        let pool = pool(
            &dir.path().join("failed_script.db"),
            &dir.path().join("locks"),
        );
        pool.writer()
            .unwrap()
            .autocommit(|conn| {
                conn.execute_batch("CREATE TABLE pooled_owner_probe(value INTEGER)")?;
                Ok(())
            })
            .unwrap();
        let drops_before = pool
            .writer_acquisition_snapshot()
            .writer_guard_drop_rollbacks;
        let rollbacks = Arc::new(AtomicUsize::new(0));
        let observed = Arc::clone(&rollbacks);
        let body = move |conn: &Connection| -> Result<(), SqliteError> {
            conn.authorizer(Some(move |context: AuthContext<'_>| {
                if matches!(
                    context.action,
                    AuthAction::Transaction {
                        operation: TransactionOperation::Rollback
                    }
                ) {
                    observed.fetch_add(1, Ordering::SeqCst);
                }
                Authorization::Allow
            }))?;
            conn.execute_batch(
                "BEGIN IMMEDIATE; INSERT INTO pooled_owner_probe VALUES(1); \
                 INSERT INTO missing_public_script_table VALUES(1)",
            )?;
            Ok(())
        };
        let error = if standalone {
            pool.standalone_autocommit(body)
        } else {
            pool.writer().unwrap().autocommit(body)
        }
        .expect_err("the unfinished script must retain its native statement failure");
        let source = match &error {
            SqliteError::Write { stage, source } => {
                assert_eq!(*stage, SqliteWriteStage::Statement);
                source
            }
            other => panic!("expected the original native write error, got {other:?}"),
        };
        assert!(source.to_string().contains("missing_public_script_table"));
        assert_eq!(
            error.write_failure(),
            Some(SqliteWriteFailure {
                stage: SqliteWriteStage::Statement,
                primary_code: rusqlite::ffi::SQLITE_ERROR,
                extended_code: rusqlite::ffi::SQLITE_ERROR,
                settlement_unknown: false,
            })
        );
        assert_eq!(
            rollbacks.load(Ordering::SeqCst),
            1,
            "the call must execute rollback before returning its error"
        );
        assert_eq!(
            pool.writer_acquisition_snapshot()
                .writer_guard_drop_rollbacks,
            drops_before,
            "the call must settle before WriterGuard Drop"
        );
        assert_eq!(count(&pool), 0, "read before any later write callback");
        assert_eq!(rollbacks.load(Ordering::SeqCst), 1);

        pool.writer()
            .expect("the failed script released its owner and volume lease")
            .autocommit(|conn| {
                assert!(conn.is_autocommit());
                conn.authorizer(None::<fn(AuthContext<'_>) -> Authorization>)?;
                conn.execute_batch("INSERT INTO pooled_owner_probe VALUES(2)")?;
                Ok(())
            })
            .expect("the writer is reusable after the original statement error");
        assert_eq!(count(&pool), 1);
    }
}