lora-python 0.19.0__tar.gz → 0.20.0__tar.gz

{lora_python-0.19.0 → lora_python-0.20.0}/Cargo.lock

@@ -854,7 +854,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "lora-ast",
  "lora-builtins-meta",
@@ -865,14 +865,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -880,11 +880,11 @@ dependencies = [
 
 [[package]]
 name = "lora-builtins-meta"
-version = "0.19.0"
+version = "0.20.0"
 
 [[package]]
 name = "lora-compiler"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -893,7 +893,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -918,7 +918,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -941,7 +941,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -953,7 +953,7 @@ dependencies = [
 
 [[package]]
 name = "lora-io"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "lora-executor",
  "lora-store",
@@ -964,7 +964,7 @@ dependencies = [
 
 [[package]]
 name = "lora-node"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -979,7 +979,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -990,7 +990,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -1003,7 +1003,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -1017,7 +1017,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -1032,7 +1032,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -1047,7 +1047,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "crc32fast",
  "jiff",
@@ -1062,7 +1062,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -1072,7 +1072,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -1088,7 +1088,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.19.0"
+version = "0.20.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.19.0 → lora_python-0.20.0}/Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.19.0"
+version = "0.20.0"
 license = "BUSL-1.1"
 authors = ["LoraDB, Inc."]
 repository = "https://github.com/lora-db/lora"
@@ -15,18 +15,18 @@ 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.19.0" }
-lora-parser = { path = "crates/lora-parser", version = "=0.19.0" }
-lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.19.0" }
-lora-analyzer = { path = "crates/lora-analyzer", version = "=0.19.0" }
-lora-compiler = { path = "crates/lora-compiler", version = "=0.19.0" }
-lora-store = { path = "crates/lora-store", version = "=0.19.0" }
-lora-snapshot = { path = "crates/lora-snapshot", version = "=0.19.0", default-features = false }
-lora-io = { path = "crates/lora-io", version = "=0.19.0" }
-lora-wal = { path = "crates/lora-wal", version = "=0.19.0" }
-lora-executor = { path = "crates/lora-executor", version = "=0.19.0", default-features = false }
-lora-database = { path = "crates/lora-database", version = "=0.19.0" }
-lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.19.0" }
+lora-ast = { path = "crates/lora-ast", version = "=0.20.0" }
+lora-parser = { path = "crates/lora-parser", version = "=0.20.0" }
+lora-builtins-meta = { path = "crates/lora-builtins-meta", version = "=0.20.0" }
+lora-analyzer = { path = "crates/lora-analyzer", version = "=0.20.0" }
+lora-compiler = { path = "crates/lora-compiler", version = "=0.20.0" }
+lora-store = { path = "crates/lora-store", version = "=0.20.0" }
+lora-snapshot = { path = "crates/lora-snapshot", version = "=0.20.0", default-features = false }
+lora-io = { path = "crates/lora-io", version = "=0.20.0" }
+lora-wal = { path = "crates/lora-wal", version = "=0.20.0" }
+lora-executor = { path = "crates/lora-executor", version = "=0.20.0", default-features = false }
+lora-database = { path = "crates/lora-database", version = "=0.20.0" }
+lora-binding-buffer = { path = "crates/bindings/lora-binding-buffer", version = "=0.20.0" }
 
 # External crates.
 anyhow = "1"

{lora_python-0.19.0 → lora_python-0.20.0}/PKG-INFO

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

{lora_python-0.19.0 → lora_python-0.20.0}/crates/bindings/lora-binding-buffer/src/stream.rs

@@ -7,10 +7,10 @@
 //!   is exhausted or dropped, and that lock guard must be released on the
 //!   thread that took it, while a host may pull and drop the stream from
 //!   any thread. The stream therefore lives on an actor thread that opens
-//!   it, pulls one row per request and drops it. Actor threads are pooled,
-//!   and a request and its reply spin briefly before parking, so a stream
-//!   drained in a loop does not pay a thread start per open or a park and
-//!   wake-up per row.
+//!   it, sends its rows in chunks (reading one chunk ahead, without
+//!   committing) and drops it. Actor threads are pooled, and a request and
+//!   its reply spin briefly before parking, so a stream drained in a loop
+//!   pays neither a thread start per open nor a round trip per row.
 
 use std::collections::HashMap;
 use std::hash::{BuildHasherDefault, Hasher};
@@ -116,6 +116,31 @@ mod actor {
     type Db = Arc<Database<InMemoryGraph>>;
     type Pulled<T, E> = Result<Option<T>, E>;
 
+    /// Most rows the actor pulls for one reply.
+    const CHUNK_ROWS: usize = 256;
+    /// About how long the actor pulls for one reply before sending what it
+    /// has: long enough to spread a round trip over many rows, short
+    /// enough that the first rows of a slow query arrive promptly.
+    const CHUNK_TIME: Duration = Duration::from_micros(50);
+
+    /// How a reply's rows end.
+    enum Tail<E> {
+        /// More rows may follow: ask again.
+        More,
+        /// No rows remain; the writes are staged, not committed. The next
+        /// request commits.
+        Drained,
+        /// The stream is gone, committed (`Ok`) or rolled back (`Err`),
+        /// and the writer lock released.
+        Done(Result<(), E>),
+    }
+
+    /// One reply: the next rows, then how they end.
+    type Chunk<T, E> = (Vec<T>, Tail<E>);
+
+    /// What the actor reports once it opened the stream (or failed to).
+    type Opened<T, E> = Result<(Vec<String>, Chunk<T, E>), E>;
+
     /// [`WriteStream`]s started and not yet done (their actor may hold or
     /// wait for the writer lock), process-wide.
     static ACTIVE: AtomicUsize = AtomicUsize::new(0);
@@ -144,13 +169,22 @@ mod actor {
     /// A mutating stream on its actor thread. Pull it and drop it on any
     /// thread; dropping an unfinished one rolls it back and releases the
     /// writer lock before `drop` returns.
+    ///
+    /// The actor sends rows in chunks and reads one chunk ahead of the
+    /// consumer, pulling with [`lora_database::QueryStream::pull`], which
+    /// does not commit at the end. It commits only when the consumer asks
+    /// for the row after the last one, so a stream abandoned before that
+    /// still rolls back.
     pub struct WriteStream<T, E> {
         columns: Vec<String>,
+        /// Rows received and not yet handed out.
+        rows: std::vec::IntoIter<T>,
+        /// How the received rows end.
+        tail: Tail<E>,
         requests: Option<Sender<()>>,
-        replies: Receiver<Pulled<T, E>>,
+        replies: Receiver<Chunk<T, E>>,
         /// Disconnects once the actor has dropped the stream.
         done: Receiver<()>,
-        ended: bool,
     }
 
     impl<T, E> WriteStream<T, E>
@@ -185,8 +219,8 @@ mod actor {
             F: FnMut(Row) -> Result<T, E> + Send + 'static,
         {
             let (requests, inbox) = mpsc::channel::<()>();
-            let (reply, replies) = mpsc::channel::<Pulled<T, E>>();
-            let (opened_tx, opened) = mpsc::sync_channel::<Result<Vec<String>, E>>(1);
+            let (reply, replies) = mpsc::channel::<Chunk<T, E>>();
+            let (opened_tx, opened) = mpsc::sync_channel::<Opened<T, E>>(1);
             let (done_tx, done) = mpsc::channel::<()>();
             let active = Active::enter();
             let job = move || {
@@ -204,31 +238,55 @@ mod actor {
                         return;
                     }
                 };
-                if opened_tx.send(Ok(stream.columns().to_vec())).is_err() {
+                let columns = stream.columns().to_vec();
+                // The first rows travel with the open.
+                let chunk = pull_chunk(&mut stream, &mut map);
+                let mut drained = matches!(chunk.1, Tail::Drained);
+                if let Tail::Done(_) = chunk.1 {
+                    // An error: roll back and release the writer lock
+                    // before the caller hears of it.
+                    drop(stream);
+                    let _ = opened_tx.send(Ok((columns, chunk)));
+                    return;
+                }
+                if opened_tx.send(Ok((columns, chunk))).is_err() {
                     // Nobody waits for it any more: roll back.
                     return;
                 }
-                while recv(&inbox).is_ok() {
-                    let pulled = match stream.next_row() {
-                        Ok(Some(row)) => map(row).map(Some),
-                        Ok(None) => Ok(None),
-                        Err(e) => Err(E::from(LoraError::from_anyhow(e))),
-                    };
-                    if matches!(pulled, Ok(Some(_))) {
-                        if reply.send(pulled).is_err() {
-                            return;
+                loop {
+                    // Read the next chunk while the caller consumes the
+                    // last one. Once drained, the next request commits.
+                    let chunk = (!drained).then(|| pull_chunk(&mut stream, &mut map));
+                    if let Some((_, Tail::Done(_))) = chunk {
+                        // An error: roll back and release the writer lock
+                        // at once; the caller hears of it after the rows
+                        // before it.
+                        drop(stream);
+                        if recv(&inbox).is_ok() {
+                            let _ = reply.send(chunk.expect("chunk checked above"));
                         }
-                    } else {
-                        // End or error: finish the stream (commit or roll
-                        // back) and release the writer lock before the
-                        // caller hears of it.
+                        return;
+                    }
+                    if recv(&inbox).is_err() {
+                        // The handle was dropped: `stream` drops here,
+                        // rolling back.
+                        return;
+                    }
+                    let Some(chunk) = chunk else {
+                        let committed = stream
+                            .finish()
+                            .map_err(|e| E::from(LoraError::from_anyhow(e)));
+                        // Release the writer lock before the caller hears
+                        // of the commit.
                         drop(stream);
-                        let _ = reply.send(pulled);
+                        let _ = reply.send((Vec::new(), Tail::Done(committed)));
+                        return;
+                    };
+                    drained = matches!(chunk.1, Tail::Drained);
+                    if reply.send(chunk).is_err() {
                         return;
                     }
                 }
-                // The handle was dropped: `stream` drops here, rolling back
-                // if it was not exhausted.
             };
             run_pooled(Box::new(job))
                 .map_err(|e| E::from(internal(format!("could not start stream thread: {e}"))))?;
@@ -245,21 +303,62 @@ mod actor {
         /// Pull the next row: `None` at the end (the writes are then
         /// committed). An error rolls the writes back. Both end the
         /// stream; later pulls report the end.
+        #[inline]
         pub fn next_row(&mut self) -> Pulled<T, E> {
-            if self.ended {
-                return Ok(None);
+            if let Some(row) = self.rows.next() {
+                return Ok(Some(row));
+            }
+            self.refill()
+        }
+
+        /// Out of received rows: finish per the tail, or ask the actor for
+        /// more (or, once drained, to commit).
+        #[cold]
+        fn refill(&mut self) -> Pulled<T, E> {
+            loop {
+                match std::mem::replace(&mut self.tail, Tail::Done(Ok(()))) {
+                    Tail::Done(result) => return result.map(|()| None),
+                    Tail::More | Tail::Drained => {}
+                }
+                let closed = || E::from(internal("query stream thread exited".into()));
+                let sent = self.requests.as_ref().map(|requests| requests.send(()));
+                if !matches!(sent, Some(Ok(()))) {
+                    return Err(closed());
+                }
+                let Ok((rows, tail)) = recv(&self.replies) else {
+                    return Err(closed());
+                };
+                self.rows = rows.into_iter();
+                self.tail = tail;
+                if let Some(row) = self.rows.next() {
+                    return Ok(Some(row));
+                }
             }
-            let closed = || E::from(internal("query stream thread exited".into()));
-            let sent = self.requests.as_ref().map(|requests| requests.send(()));
-            if !matches!(sent, Some(Ok(()))) {
-                self.ended = true;
-                return Err(closed());
+        }
+    }
+
+    /// Pull up to [`CHUNK_ROWS`] rows, or for about [`CHUNK_TIME`], without
+    /// committing. On an error the stream has rolled back.
+    fn pull_chunk<T, E, F>(stream: &mut lora_database::QueryStream<'_>, map: &mut F) -> Chunk<T, E>
+    where
+        E: From<LoraError>,
+        F: FnMut(Row) -> Result<T, E>,
+    {
+        let start = Instant::now();
+        let mut rows = Vec::new();
+        loop {
+            let row = match stream.pull() {
+                Ok(Some(row)) => row,
+                Ok(None) => return (rows, Tail::Drained),
+                Err(e) => return (rows, Tail::Done(Err(E::from(LoraError::from_anyhow(e))))),
+            };
+            match map(row) {
+                Ok(row) => rows.push(row),
+                Err(e) => return (rows, Tail::Done(Err(e))),
             }
-            let pulled = recv(&self.replies).map_err(|_| closed()).and_then(|p| p);
-            if !matches!(pulled, Ok(Some(_))) {
-                self.ended = true;
+            if rows.len() >= CHUNK_ROWS || (rows.len() % 16 == 0 && start.elapsed() >= CHUNK_TIME) {
+                return (rows, Tail::More);
             }
-            pulled
         }
     }
 
@@ -268,10 +367,10 @@ mod actor {
     /// has opened it.
     pub struct OpeningStream<T, E> {
         parts: Option<Parts<T, E>>,
-        opened: Receiver<Result<Vec<String>, E>>,
+        opened: Receiver<Opened<T, E>>,
     }
 
-    type Parts<T, E> = (Sender<()>, Receiver<Pulled<T, E>>, Receiver<()>);
+    type Parts<T, E> = (Sender<()>, Receiver<Chunk<T, E>>, Receiver<()>);
 
     impl<T, E> OpeningStream<T, E>
     where
@@ -296,9 +395,9 @@ mod actor {
 
         fn finish(
             mut self,
-            opened: Result<Result<Vec<String>, E>, RecvError>,
+            opened: Result<Opened<T, E>, RecvError>,
         ) -> Result<WriteStream<T, E>, E> {
-            let columns =
+            let (columns, (rows, tail)) =
                 opened.map_err(|_| E::from(internal("stream thread exited".into())))??;
             let (requests, replies, done) = self
                 .parts
@@ -306,18 +405,19 @@ mod actor {
                 .ok_or_else(|| E::from(internal("stream already opened".into())))?;
             Ok(WriteStream {
                 columns,
+                rows: rows.into_iter(),
+                tail,
                 requests: Some(requests),
                 replies,
                 done,
-                ended: false,
             })
         }
     }
 
     impl<T, E> Drop for WriteStream<T, E> {
         /// Stop the actor and wait for it to drop the stream (rolling back
-        /// an unfinished one). The actor is idle between pulls, so this is
-        /// prompt.
+        /// an unfinished one). The actor pulls at most one chunk between
+        /// requests, so this is prompt.
         fn drop(&mut self) {
             self.requests.take();
             let _ = recv(&self.done);

{lora_python-0.19.0 → lora_python-0.20.0}/crates/bindings/lora-python/src/stream.rs

@@ -11,9 +11,10 @@
 //! dropped off its thread, and with it the writer lock, hanging every later
 //! write). So a mutating stream lives on a dedicated thread (an actor, a
 //! pooled thread from `lora_binding_buffer::stream::WriteStream`): the
-//! thread opens the stream, pulls a row per request, and drops the stream
-//! (committing an exhausted one, rolling back an unfinished one) before it
-//! is done. Once open, the actor waits only for its handle's requests and
+//! thread opens the stream, sends its rows in chunks, reading one chunk
+//! ahead without committing, and drops the stream (committing once the
+//! caller has pulled past the last row, rolling back an unfinished one)
+//! before it is done. Once open, the actor waits only for its handle's requests and
 //! never needs the GIL, so a request is always answered promptly.
 //!
 //! Whether a query streams as a write comes from a per-database

{lora_python-0.19.0 → lora_python-0.20.0}/crates/bindings/lora-python/tests/test_sync.py

@@ -533,6 +533,50 @@ def test_stream_and_transaction_helpers() -> None:
     ]
 
 
+def _count(db: Database, label: str) -> int:
+    return db.execute(f"MATCH (n:{label}) RETURN count(n) AS c")["rows"][0]["c"]
+
+
+def test_mutating_stream_commits_only_at_its_end() -> None:
+    # Many rows, so the native side sends several chunks ahead of the
+    # iteration; the writes commit only once the iteration reaches the end.
+    db = Database.create()
+    query = "UNWIND list.range(1, 2000) AS i CREATE (:Chunked {i: i}) RETURN i"
+    assert [row["i"] for row in db.stream(query)] == list(range(1, 2001))
+    assert _count(db, "Chunked") == 2000
+
+    # Every row read, but not the end: closing rolls back.
+    stream = db.stream(query.replace("Chunked", "AllButEnd"))
+    assert [next(stream)["i"] for _ in range(2000)] == list(range(1, 2001))
+    stream.close()
+    assert _count(db, "AllButEnd") == 0
+
+    # Abandoned mid-way, past the first chunk: rolls back and frees the lock.
+    stream = db.stream(query.replace("Chunked", "Abandoned"))
+    for _ in range(700):
+        next(stream)
+    del stream
+    assert _count(db, "Abandoned") == 0
+    db.execute("CREATE (:AfterAbandon)")
+    assert _count(db, "AfterAbandon") == 1
+
+
+def test_mutating_stream_error_mid_stream_rolls_back() -> None:
+    # A query ending in a write streams row by row: the duplicate fails
+    # after 499 nodes were created, on the first pull.
+    db = Database.create()
+    db.execute("CREATE CONSTRAINT failing_id FOR (n:Failing) REQUIRE n.id IS UNIQUE")
+    xs = list(range(1, 600))
+    xs[499] = 1
+    stream = db.stream("UNWIND $xs AS x CREATE (:Failing {id: x})", {"xs": xs})
+    with pytest.raises(LoraQueryError):
+        next(stream)
+    assert list(stream) == []
+    assert _count(db, "Failing") == 0
+    db.execute("CREATE (:AfterError)")
+    assert _count(db, "AfterError") == 1
+
+
 def test_is_vector_returns_false_for_non_vectors() -> None:
     from lora_python import is_vector
 

{lora_python-0.19.0 → lora_python-0.20.0}/crates/lora-compiler/src/lib.rs

@@ -12,7 +12,7 @@ pub use logical::{
     Aggregation, Argument, Create, Delete, Expand, Filter, Foreach, Limit, LogicalOp, LogicalPlan,
     Merge, NodeByPointScan, NodeByPropertyRangeScan, NodeByPropertyScan, NodeByTextScan, NodeScan,
     OptionalMatch, PathBuild, PlanNodeId, PointPredicate, Projection, RelByPointScan,
-    RelByPropertyRangeScan, RelByTextScan, Remove, Set, Sort, TextPredicate, Unwind,
+    RelByPropertyRangeScan, RelByTextScan, Remove, Set, Sort, SortLimit, TextPredicate, Unwind,
 };
 pub use optimizer::Optimizer;
 pub use physical::{

{lora_python-0.19.0 → lora_python-0.20.0}/crates/lora-compiler/src/logical.rs

@@ -280,6 +280,17 @@ pub struct Sort {
     /// Optional upper bound for rows the sort must retain because a parent
     /// LIMIT will discard everything after this many sorted rows.
     pub top_k: Option<usize>,
+    /// The parent LIMIT's `SKIP` / `LIMIT` expressions when they are not
+    /// literals (`LIMIT $n`): the executor evaluates them once per run and
+    /// keeps only `skip + limit` rows, like a static [`Sort::top_k`].
+    pub limit: Option<SortLimit>,
+}
+
+/// A parent LIMIT's row bound, evaluated at run time (see [`Sort::limit`]).
+#[derive(Debug, Clone)]
+pub struct SortLimit {
+    pub skip: Option<ResolvedExpr>,
+    pub limit: ResolvedExpr,
 }
 
 #[derive(Debug, Clone)]

{lora_python-0.19.0 → lora_python-0.20.0}/crates/lora-compiler/src/optimizer.rs

@@ -130,12 +130,32 @@ impl Optimizer {
     fn annotate_top_k_sorts(&self, plan: &mut LogicalPlan) {
         let len = plan.nodes.len();
         for i in 0..len {
-            let Some((input, bound)) = limit_sort_bound(&plan.nodes[i]) else {
+            let LogicalOp::Limit(limit) = &plan.nodes[i] else {
                 continue;
             };
-
-            if let Some(sort) = sort_op_mut(&mut plan.nodes[input]) {
-                sort.top_k = merge_top_k_bound(sort.top_k, bound);
+            let input = limit.input;
+            match limit_sort_bound(&plan.nodes[i]) {
+                Some((_, bound)) => {
+                    if let Some(sort) = sort_op_mut(&mut plan.nodes[input]) {
+                        sort.top_k = merge_top_k_bound(sort.top_k, bound);
+                    }
+                }
+                // `LIMIT $n`: bound the sort with the same expressions,
+                // evaluated once per run.
+                None => {
+                    let Some(limit_expr) = limit.limit.clone() else {
+                        continue;
+                    };
+                    let skip = limit.skip.clone();
+                    if let Some(sort) = sort_op_mut(&mut plan.nodes[input]) {
+                        if sort.limit.is_none() {
+                            sort.limit = Some(SortLimit {
+                                skip,
+                                limit: limit_expr,
+                            });
+                        }
+                    }
+                }
             }
         }
     }
@@ -392,6 +412,7 @@ fn lower_logical_op(op: LogicalOp) -> PhysicalOp {
             input: sort.input,
             items: sort.items,
             top_k: sort.top_k,
+            limit: sort.limit,
         }),
 
         LogicalOp::Limit(limit) => PhysicalOp::Limit(LimitExec {

{lora_python-0.19.0 → lora_python-0.20.0}/crates/lora-compiler/src/physical.rs

@@ -229,6 +229,9 @@ pub struct SortExec {
     pub items: Vec<ResolvedSortItem>,
     /// Optional upper bound for rows Sort must retain before a parent LIMIT.
     pub top_k: Option<usize>,
+    /// Run-time bound from a parent `LIMIT $n` (see
+    /// [`crate::logical::Sort::limit`]).
+    pub limit: Option<crate::logical::SortLimit>,
 }
 
 #[derive(Debug, Clone)]

{lora_python-0.19.0 → lora_python-0.20.0}/crates/lora-compiler/src/plan_tree.rs

@@ -357,6 +357,13 @@ fn describe(op: &PhysicalOp) -> PlanDescription {
             );
             if let Some(top_k) = n.top_k {
                 d.insert("top_k".to_string(), top_k.to_string());
+            } else if let Some(bound) = &n.limit {
+                let limit = expr_str(&bound.limit);
+                let top_k = match &bound.skip {
+                    Some(skip) => format!("{} + {limit}", expr_str(skip)),
+                    None => limit,
+                };
+                d.insert("top_k".to_string(), top_k);
             }
             PlanDescription::with_children("Sort", d, vec![n.input])
         }