lora-python 0.5.5__tar.gz → 0.5.6__tar.gz

{lora_python-0.5.5 → lora_python-0.5.6}/Cargo.lock

@@ -651,7 +651,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "lora-ast",
  "lora-parser",
@@ -661,14 +661,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-compiler"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -676,7 +676,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "anyhow",
  "criterion",
@@ -694,7 +694,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -708,7 +708,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -718,7 +718,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -732,7 +732,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "lora-ast",
  "pest",
@@ -743,7 +743,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -755,7 +755,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "anyhow",
  "axum",
@@ -769,7 +769,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "bincode",
  "crc32fast",
@@ -781,7 +781,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "bincode",
  "crc32fast",
@@ -792,7 +792,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -807,7 +807,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.5.5"
+version = "0.5.6"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.5.5 → lora_python-0.5.6}/Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.5.5"
+version = "0.5.6"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,14 +15,14 @@ rust-version = "1.87"
 # Internal crates — versions are kept in lockstep with [workspace.package].version
 # by `scripts/sync-versions.mjs`. Both `path` and `version` are set so that
 # `cargo publish` works (crates.io cannot resolve path-only deps).
-lora-ast = { path = "crates/lora-ast", version = "=0.5.5" }
-lora-parser = { path = "crates/lora-parser", version = "=0.5.5" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.5.5" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.5.5" }
-lora-store = { path = "crates/lora-store", version = "=0.5.5" }
-lora-wal = { path = "crates/lora-wal", version = "=0.5.5" }
-lora-executor = { path = "crates/lora-executor", version = "=0.5.5" }
-lora-database = { path = "crates/lora-database", version = "=0.5.5" }
+lora-ast = { path = "crates/lora-ast", version = "=0.5.6" }
+lora-parser = { path = "crates/lora-parser", version = "=0.5.6" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.5.6" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.5.6" }
+lora-store = { path = "crates/lora-store", version = "=0.5.6" }
+lora-wal = { path = "crates/lora-wal", version = "=0.5.6" }
+lora-executor = { path = "crates/lora-executor", version = "=0.5.6" }
+lora-database = { path = "crates/lora-database", version = "=0.5.6" }
 
 # External crates.
 anyhow = "1"

{lora_python-0.5.5 → lora_python-0.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lora-python
-Version: 0.5.5
+Version: 0.5.6
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.8

{lora_python-0.5.5 → lora_python-0.5.6}/crates/lora-database/src/archive.rs

@@ -24,8 +24,11 @@ static ARCHIVE_TMP_COUNTER: AtomicU64 = AtomicU64::new(0);
 /// `.loradb` target. Any ZIP-compatible tool (WinRAR, Explorer, unzip, 7-Zip)
 /// can inspect the resulting database file.
 pub(crate) struct WalArchive {
+    archive_path: PathBuf,
     work_dir: PathBuf,
+    max_archive_bytes: u64,
     state: Arc<(Mutex<ArchiveState>, Condvar)>,
+    write_lock: Arc<Mutex<()>>,
     worker: Option<JoinHandle<()>>,
     _archive_lock: ArchiveLock,
 }
@@ -56,16 +59,21 @@ impl WalArchive {
         prepare_work_dir(&archive_path, &work_dir, max_archive_bytes)?;
 
         let state = Arc::new((Mutex::new(ArchiveState::default()), Condvar::new()));
+        let write_lock = Arc::new(Mutex::new(()));
         let worker = Some(spawn_archive_worker(
             state.clone(),
+            write_lock.clone(),
             work_dir.clone(),
             archive_path.clone(),
             max_archive_bytes,
         ));
 
         Ok(Self {
+            archive_path,
             work_dir,
+            max_archive_bytes,
             state,
+            write_lock,
             worker,
             _archive_lock: archive_lock,
         })
@@ -95,6 +103,50 @@ impl WalMirror for WalArchive {
         cv.notify_one();
         Ok(())
     }
+
+    fn persist_force(&self, wal_dir: &Path) -> Result<(), WalError> {
+        if wal_dir != self.work_dir {
+            return Err(WalError::Malformed(format!(
+                "archive mirror received unexpected WAL dir: {}",
+                wal_dir.display()
+            )));
+        }
+        {
+            let (lock, _) = &*self.state;
+            let state = lock.lock().unwrap();
+            if let Some(failure) = &state.failure {
+                return Err(WalError::Malformed(format!(
+                    "database archive writer failed: {failure}"
+                )));
+            }
+        }
+
+        let _write_guard = self.write_lock.lock().unwrap();
+        {
+            let (lock, _) = &*self.state;
+            let state = lock.lock().unwrap();
+            if let Some(failure) = &state.failure {
+                return Err(WalError::Malformed(format!(
+                    "database archive writer failed: {failure}"
+                )));
+            }
+        }
+        let result =
+            write_archive_atomic(&self.work_dir, &self.archive_path, self.max_archive_bytes);
+        let (lock, _) = &*self.state;
+        let mut state = lock.lock().unwrap();
+        match result {
+            Ok(()) => {
+                state.dirty = false;
+                state.force = false;
+                Ok(())
+            }
+            Err(err) => {
+                state.failure = Some(err.to_string());
+                Err(err)
+            }
+        }
+    }
 }
 
 impl Drop for WalArchive {
@@ -102,10 +154,9 @@ impl Drop for WalArchive {
         {
             let (lock, cv) = &*self.state;
             let mut state = lock.lock().unwrap();
-            // The async archive worker may have already consumed the dirty flag
-            // before Group-mode WAL bytes were forced out of the in-memory
-            // segment buffer. Drop runs after the WAL handle is dropped, so
-            // always take one final archive snapshot from the now-flushed work
+            // The async archive worker may not have observed the latest dirty
+            // flag yet. Drop runs after the WAL handle is dropped, so always
+            // take one final archive snapshot from the fully flushed work
             // directory.
             state.dirty = true;
             state.shutdown = true;
@@ -132,6 +183,7 @@ impl Drop for WalArchive {
 
 fn spawn_archive_worker(
     state: Arc<(Mutex<ArchiveState>, Condvar)>,
+    write_lock: Arc<Mutex<()>>,
     work_dir: PathBuf,
     archive_path: PathBuf,
     max_archive_bytes: u64,
@@ -157,6 +209,7 @@ fn spawn_archive_worker(
         };
 
         if should_flush {
+            let _write_guard = write_lock.lock().unwrap();
             if let Err(err) = write_archive_atomic(&work_dir, &archive_path, max_archive_bytes) {
                 let (lock, _) = &*state;
                 let mut guard = lock.lock().unwrap();
@@ -373,9 +426,8 @@ fn cleanup_stale_temp_paths(archive_path: &Path) -> Result<(), WalError> {
         let Some(file_name) = file_name.to_str() else {
             continue;
         };
-        let is_archive_tmp =
-            file_name.starts_with(&archive_tmp_prefix) && file_name.ends_with(".tmp");
-        let is_extract_tmp = file_name.starts_with(&extract_tmp_prefix);
+        let is_archive_tmp = is_generated_archive_tmp_name(file_name, &archive_tmp_prefix);
+        let is_extract_tmp = is_generated_extract_tmp_name(file_name, &extract_tmp_prefix);
         if !is_archive_tmp && !is_extract_tmp {
             continue;
         }
@@ -390,6 +442,37 @@ fn cleanup_stale_temp_paths(archive_path: &Path) -> Result<(), WalError> {
     Ok(())
 }
 
+fn is_generated_archive_tmp_name(file_name: &str, prefix: &str) -> bool {
+    let Some(rest) = file_name.strip_prefix(prefix) else {
+        return false;
+    };
+    let Some(rest) = rest.strip_suffix(".tmp") else {
+        return false;
+    };
+    let mut parts = rest.split('.');
+    matches!(
+        (parts.next(), parts.next(), parts.next(), parts.next()),
+        (Some(pid), Some(nanos), Some(sequence), None)
+            if is_ascii_digits(pid) && is_ascii_digits(nanos) && is_ascii_digits(sequence)
+    )
+}
+
+fn is_generated_extract_tmp_name(file_name: &str, prefix: &str) -> bool {
+    let Some(rest) = file_name.strip_prefix(prefix) else {
+        return false;
+    };
+    let mut parts = rest.split('.');
+    matches!(
+        (parts.next(), parts.next(), parts.next(), parts.next()),
+        (Some(pid), Some(nanos), Some(sequence), None)
+            if is_ascii_digits(pid) && is_ascii_digits(nanos) && is_ascii_digits(sequence)
+    )
+}
+
+fn is_ascii_digits(value: &str) -> bool {
+    !value.is_empty() && value.bytes().all(|b| b.is_ascii_digit())
+}
+
 fn sorted_wal_files(wal_dir: &Path) -> Result<Vec<PathBuf>, WalError> {
     let mut entries = Vec::new();
     for entry in fs::read_dir(wal_dir)? {

{lora_python-0.5.5 → lora_python-0.5.6}/crates/lora-database/src/database.rs

@@ -140,6 +140,15 @@ impl Database<InMemoryGraph> {
         Ok(Transaction::new(live, self.wal.clone(), mode))
     }
 
+    /// Force any pending WAL bytes to durable storage and, for archive-backed
+    /// databases, refresh the portable `.loradb` file before returning.
+    pub fn sync(&self) -> Result<()> {
+        if let Some(wal) = &self.wal {
+            wal.force_fsync()?;
+        }
+        Ok(())
+    }
+
     /// Restore from a snapshot file then replay any WAL records past
     /// it.
     ///
@@ -596,32 +605,42 @@ where
     // instead, so swapping in a new backend only requires changing one type
     // parameter.
 
-    /// Drop every node and relationship.
+    /// Drop every node and relationship, returning WAL/archive errors to the
+    /// caller.
     ///
-    /// When a WAL is attached, `clear()` is wrapped in `arm`/`commit`
-    /// so the `MutationEvent::Clear` fired by the store reaches the
-    /// log inside a transaction (without arming, the recorder would
-    /// poison itself on the first event). WAL failures here are
-    /// best-effort: the in-memory state is still cleared so the
-    /// caller's contract holds, but the recorder's poisoned flag
-    /// will surface to the next query.
-    pub fn clear(&self) {
+    /// When a WAL is attached, the clear is wrapped in `arm`/`commit` so the
+    /// `MutationEvent::Clear` fired by the store reaches the log inside a
+    /// transaction. If a failure happens after the in-memory graph has been
+    /// cleared, the recorder is poisoned by the failing WAL path and future
+    /// writes fail until the database is reopened from durable state.
+    pub fn try_clear(&self) -> Result<()> {
         let mut guard = self.write_store();
-        match &self.wal {
-            None => guard.clear(),
-            Some(rec) => {
-                let armed = rec.arm();
-                guard.clear();
-                if armed.is_ok() {
-                    // `clear()` always emits a `MutationEvent::Clear`,
-                    // so commit returns `WroteCommit::Yes` and we
-                    // flush. If that order ever changes, the worst
-                    // case is one redundant flush call.
-                    let _ = rec.commit();
-                    let _ = rec.flush();
-                }
+        let Some(rec) = &self.wal else {
+            guard.clear();
+            return Ok(());
+        };
+
+        rec.arm().map_err(|e| anyhow!("WAL arm failed: {e}"))?;
+        guard.clear();
+        match rec.commit() {
+            Ok(WroteCommit::Yes) => {
+                rec.flush().map_err(|e| anyhow!("WAL flush failed: {e}"))?;
             }
+            Ok(WroteCommit::No) => {}
+            Err(e) => return Err(anyhow!("WAL commit failed: {e}")),
+        }
+        if let Some(reason) = rec.poisoned() {
+            return Err(anyhow!("WAL poisoned: {reason}"));
         }
+        Ok(())
+    }
+
+    /// Drop every node and relationship.
+    ///
+    /// This compatibility helper keeps the historical infallible Rust API.
+    /// Bindings that can report errors should call [`Self::try_clear`].
+    pub fn clear(&self) {
+        let _ = self.try_clear();
     }
 
     /// Number of nodes currently in the graph.

{lora_python-0.5.5 → lora_python-0.5.6}/crates/lora-database/tests/wal.rs

@@ -251,6 +251,92 @@ fn named_database_recovers_from_durable_sidecar_when_archive_lags() {
     );
 }
 
+#[test]
+fn named_database_sync_makes_archive_immediately_portable() {
+    let dir = TmpDir::new("named-sync-source");
+    let portable_dir = TmpDir::new("named-sync-copy");
+
+    let db = Database::open_named(
+        "app",
+        DatabaseOpenOptions {
+            sync_mode: SyncMode::Group {
+                interval_ms: 60_000,
+            },
+            ..DatabaseOpenOptions::default().with_database_dir(dir.path())
+        },
+    )
+    .unwrap();
+    db.execute("CREATE (:Synced {id: 1})", rows()).unwrap();
+    db.sync().unwrap();
+
+    std::fs::copy(
+        dir.path().join("app.loradb"),
+        portable_dir.path().join("app.loradb"),
+    )
+    .unwrap();
+
+    let recovered = Database::open_named(
+        "app",
+        DatabaseOpenOptions::default().with_database_dir(portable_dir.path()),
+    )
+    .unwrap();
+    assert_eq!(recovered.node_count(), 1);
+}
+
+#[test]
+fn named_database_clear_persists_through_archive() {
+    let dir = TmpDir::new("named-clear");
+
+    {
+        let db = Database::open_named(
+            "app",
+            DatabaseOpenOptions::default().with_database_dir(dir.path()),
+        )
+        .unwrap();
+        db.execute("CREATE (:A {id: 1})-[:R]->(:B {id: 2})", rows())
+            .unwrap();
+        db.try_clear().unwrap();
+        assert_eq!(db.node_count(), 0);
+        assert_eq!(db.relationship_count(), 0);
+    }
+
+    let recovered = Database::open_named(
+        "app",
+        DatabaseOpenOptions::default().with_database_dir(dir.path()),
+    )
+    .unwrap();
+    assert_eq!(recovered.node_count(), 0);
+    assert_eq!(recovered.relationship_count(), 0);
+}
+
+#[test]
+fn named_database_cleanup_only_removes_generated_temp_paths() {
+    let dir = TmpDir::new("named-temp-cleanup");
+    let unrelated_file = dir.path().join("app.loradb.user.tmp");
+    let unrelated_dir = dir.path().join("app.loradb.wal.extract.user");
+    let generated_file = dir.path().join("app.loradb.1.2.3.tmp");
+    let generated_dir = dir.path().join("app.loradb.wal.extract.1.2.3");
+
+    std::fs::write(&unrelated_file, b"keep").unwrap();
+    std::fs::create_dir(&unrelated_dir).unwrap();
+    std::fs::write(&generated_file, b"delete").unwrap();
+    std::fs::create_dir(&generated_dir).unwrap();
+
+    {
+        let db = Database::open_named(
+            "app",
+            DatabaseOpenOptions::default().with_database_dir(dir.path()),
+        )
+        .unwrap();
+        db.sync().unwrap();
+    }
+
+    assert!(unrelated_file.exists());
+    assert!(unrelated_dir.exists());
+    assert!(!generated_file.exists());
+    assert!(!generated_dir.exists());
+}
+
 #[test]
 fn named_database_rejects_invalid_archive_without_publishing_partial_sidecar() {
     let dir = TmpDir::new("named-invalid-archive");
@@ -367,10 +453,9 @@ fn named_database_final_archive_flush_captures_group_buffer() {
         )
         .unwrap();
 
-        // Let the archive debounce worker observe the dirty flag before the
-        // Group-mode WAL flusher runs. The final archive flush on drop must
-        // still snapshot the force-flushed WAL bytes, not the earlier empty
-        // segment file.
+        // Let the archive debounce worker run before the clean shutdown path.
+        // The final archive flush on drop must still publish a complete,
+        // reopenable archive.
         std::thread::sleep(std::time::Duration::from_millis(1_200));
     }
 

{lora_python-0.5.5 → lora_python-0.5.6}/crates/lora-wal/src/config.rs

@@ -14,9 +14,11 @@ pub enum SyncMode {
     #[default]
     PerCommit,
 
-    /// Buffer commits and `fsync` on a fixed cadence on a background
-    /// thread. Trades the last `interval_ms` of commits for higher
-    /// throughput on bulk-load workloads.
+    /// Write commit bytes to the OS immediately, then `fsync` on a fixed
+    /// cadence on a background thread. This survives ordinary process death
+    /// after `flush()` returns, but can still trade the last `interval_ms` of
+    /// commits on power loss or kernel crash for higher throughput on
+    /// bulk-load workloads.
     ///
     /// A background fsync failure poisons the WAL: the next `commit` /
     /// `flush` / `force_fsync` returns [`crate::WalError::Poisoned`] and

{lora_python-0.5.5 → lora_python-0.5.6}/crates/lora-wal/src/recorder_adapter.rs

@@ -76,6 +76,10 @@ pub enum WroteCommit {
 /// databases.
 pub trait WalMirror: Send + Sync {
     fn persist(&self, wal_dir: &Path) -> Result<(), WalError>;
+
+    fn persist_force(&self, wal_dir: &Path) -> Result<(), WalError> {
+        self.persist(wal_dir)
+    }
 }
 
 #[derive(Default)]
@@ -246,7 +250,7 @@ impl WalRecorder {
             state.poisoned = Some(e.to_string());
         })?;
         if let Some(mirror) = &self.mirror {
-            mirror.persist(self.wal.dir()).inspect_err(|e| {
+            mirror.persist_force(self.wal.dir()).inspect_err(|e| {
                 state.poisoned = Some(e.to_string());
             })?;
         }
@@ -274,7 +278,7 @@ impl WalRecorder {
         // full WAL history is the only safe way to let the archive recover by
         // itself after a checkpoint marker.
         if let Some(mirror) = &self.mirror {
-            mirror.persist(self.wal.dir())?;
+            mirror.persist_force(self.wal.dir())?;
             return Ok(());
         }
         self.wal.truncate_up_to(fence_lsn)?;

{lora_python-0.5.5 → lora_python-0.5.6}/crates/lora-wal/src/wal.rs

@@ -378,8 +378,8 @@ impl Wal {
     /// - `PerCommit` — write the buffer to the OS, `fsync`, and
     ///   advance `durable_lsn`. The strongest contract: every
     ///   record up to `next_lsn - 1` is on disk.
-    /// - `Group` — leave the buffer in memory. The background flusher
-    ///   writes, fsyncs, and advances `durable_lsn` on its cadence.
+    /// - `Group` — write the buffer to the OS, but let the background
+    ///   flusher fsync and advance `durable_lsn` on its cadence.
     /// - `None` — write the buffer to the OS only, but advance
     ///   `durable_lsn` anyway. The mode opts out of crash
     ///   durability, so the checkpoint fence reports
@@ -407,9 +407,9 @@ impl Wal {
         let written_lsn = Lsn::new(state.next_lsn.raw().saturating_sub(1));
 
         // Decide whether this call is allowed to advance
-        // `durable_lsn`. The bg flusher's job in Group mode is
-        // exactly to do that "out of band"; PerCommit and None do it
-        // inline; Group's user-driven `flush()` does not.
+        // `durable_lsn`. The bg flusher's job in Group mode is to advance
+        // that fence after fsync; PerCommit and None do it inline; Group's
+        // user-driven `flush()` only pushes bytes to the OS.
         let do_fsync = matches!(
             (kind, self.sync_mode),
             (FlushKind::ForceFsync, _) | (_, SyncMode::PerCommit)
@@ -419,14 +419,7 @@ impl Wal {
             (FlushKind::ForceFsync, _) | (_, SyncMode::PerCommit) | (_, SyncMode::None)
         );
 
-        if matches!(
-            (kind, self.sync_mode),
-            (FlushKind::PerConfiguredMode, SyncMode::Group { .. })
-        ) {
-            // Group mode batches both the write syscall and the fsync. This
-            // keeps the write-heavy hot path close to in-memory execution; the
-            // background flusher (or Drop) will force the buffer out.
-        } else if do_fsync {
+        if do_fsync {
             state.active_writer.flush_and_sync()?;
         } else {
             state.active_writer.flush_buffer()?;

{lora_python-0.5.5 → lora_python-0.5.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "lora-python"
-version = "0.5.5"
+version = "0.5.6"
 description = "Python bindings for the Lora in-memory graph database"
 readme = "README.md"
 license = { text = "BUSL-1.1" }