lora-python 0.12.0__tar.gz → 0.13.0__tar.gz

{lora_python-0.12.0 → lora_python-0.13.0}/Cargo.lock

@@ -773,7 +773,7 @@ checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lora-analyzer"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "lora-ast",
  "lora-builtins-meta",
@@ -784,14 +784,14 @@ dependencies = [
 
 [[package]]
 name = "lora-ast"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "smallvec 2.0.0-alpha.12",
 ]
 
 [[package]]
 name = "lora-binding-buffer"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "lora-database",
  "lora-store",
@@ -799,11 +799,11 @@ dependencies = [
 
 [[package]]
 name = "lora-builtins-meta"
-version = "0.12.0"
+version = "0.13.0"
 
 [[package]]
 name = "lora-compiler"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "lora-analyzer",
  "lora-ast",
@@ -812,7 +812,7 @@ dependencies = [
 
 [[package]]
 name = "lora-database"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "chacha20poly1305",
@@ -824,6 +824,7 @@ dependencies = [
  "lora-ast",
  "lora-compiler",
  "lora-executor",
+ "lora-io",
  "lora-parser",
  "lora-snapshot",
  "lora-store",
@@ -836,7 +837,7 @@ dependencies = [
 
 [[package]]
 name = "lora-executor"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -859,7 +860,7 @@ dependencies = [
 
 [[package]]
 name = "lora-ffi"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -869,9 +870,20 @@ dependencies = [
  "serde_json",
 ]
 
+[[package]]
+name = "lora-io"
+version = "0.13.0"
+dependencies = [
+ "lora-executor",
+ "lora-store",
+ "serde",
+ "serde_json",
+ "thiserror",
+]
+
 [[package]]
 name = "lora-node"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "lora-binding-buffer",
@@ -886,7 +898,7 @@ dependencies = [
 
 [[package]]
 name = "lora-parser"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "lora-ast",
  "pest",
@@ -897,7 +909,7 @@ dependencies = [
 
 [[package]]
 name = "lora-python"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "lora-database",
@@ -909,7 +921,7 @@ dependencies = [
 
 [[package]]
 name = "lora-query-wasm"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "console_error_panic_hook",
  "js-sys",
@@ -923,7 +935,7 @@ dependencies = [
 
 [[package]]
 name = "lora-server"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "axum",
@@ -937,7 +949,7 @@ dependencies = [
 
 [[package]]
 name = "lora-snapshot"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "argon2",
  "blake3",
@@ -952,7 +964,7 @@ dependencies = [
 
 [[package]]
 name = "lora-store"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "crc32fast",
  "js-sys",
@@ -963,7 +975,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wal"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "crc32fast",
  "lora-store",
@@ -973,7 +985,7 @@ dependencies = [
 
 [[package]]
 name = "lora-wasm"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "console_error_panic_hook",
@@ -989,7 +1001,7 @@ dependencies = [
 
 [[package]]
 name = "lora_ruby"
-version = "0.12.0"
+version = "0.13.0"
 dependencies = [
  "anyhow",
  "lora-database",

{lora_python-0.12.0 → lora_python-0.13.0}/Cargo.toml

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

{lora_python-0.12.0 → lora_python-0.13.0}/PKG-INFO

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

{lora_python-0.12.0 → lora_python-0.13.0}/crates/lora-analyzer/src/analyzer/clauses.rs

@@ -54,6 +54,11 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
     pub(super) fn analyze_unwind(&mut self, u: &Unwind) -> Result<ResolvedUnwind, SemanticError> {
         let expr = self.analyze_expr(&u.expr)?;
         let alias = self.declare_fresh_variable(&u.alias.name)?;
+        // UNWIND iterates a list — typically `$rows` from a batched
+        // import, where each element is a map of arbitrary keys. The
+        // analyzer can't know the row shape, so let property access on
+        // the alias skip the graph-catalog check.
+        self.dynamic_property_vars.insert(alias);
 
         Ok(ResolvedUnwind { expr, alias })
     }

{lora_python-0.12.0 → lora_python-0.13.0}/crates/lora-analyzer/src/analyzer/state.rs

@@ -4,12 +4,18 @@ use lora_ast::{
     UpdatingClause,
 };
 use lora_store::GraphCatalog;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 pub struct Analyzer<'a, S: GraphCatalog + ?Sized> {
     pub(super) storage: &'a S,
     pub(super) scopes: ScopeStack,
     pub(super) symbols: SymbolTable,
+    /// Variables whose runtime value shape isn't tracked by the analyzer
+    /// (UNWIND-bound elements, anything that may legitimately hold a map
+    /// or list of maps). Property access on these vars must skip the
+    /// graph-catalog check — the caller can't know which keys the data
+    /// carries until rows are bound at execution time.
+    pub(super) dynamic_property_vars: BTreeSet<VarId>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -26,6 +32,7 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
             storage,
             scopes: ScopeStack::new(),
             symbols: SymbolTable::default(),
+            dynamic_property_vars: BTreeSet::new(),
         }
     }
 
@@ -324,7 +331,13 @@ impl<'a, S: GraphCatalog + ?Sized> Analyzer<'a, S> {
 
     pub(super) fn property_access_allowed(&self, base: &ResolvedExpr, key: &str) -> bool {
         match base {
-            ResolvedExpr::Map(_) => true,
+            // Map literals and query parameters carry their own keys —
+            // there's nothing in the graph catalog to check against.
+            ResolvedExpr::Map(_) | ResolvedExpr::Parameter(_) => true,
+            // Variables whose value shape isn't tracked (UNWIND-bound
+            // row elements, etc.) — the catalog can't speak to keys on
+            // values that come from `$params` at execution time.
+            ResolvedExpr::Variable(id) if self.dynamic_property_vars.contains(id) => true,
             _ => {
                 self.storage.has_property_key(key)
                     || (self.storage.node_count() == 0 && self.storage.relationship_count() == 0)

{lora_python-0.12.0 → lora_python-0.13.0}/crates/lora-analyzer/src/analyzer/tests.rs

@@ -31,6 +31,42 @@ fn create_allows_new_relationship_type_when_graph_is_not_empty() {
     ));
 }
 
+#[test]
+fn unwind_alias_allows_property_access_with_unknown_keys() {
+    // Regression: when the playground import driver runs
+    //     UNWIND $rows AS r CREATE (:Label {`User Id`: r.`User Id`})
+    // against a non-empty graph that has never seen "User Id" as a
+    // property key, the analyzer used to reject `r.\`User Id\`` as an
+    // unknown property. UNWIND-bound vars hold whatever the parameter
+    // payload carries, so property access on them must skip the
+    // catalog check.
+    let mut graph = InMemoryGraph::new();
+    let _ = graph.create_node(vec!["Other".into()], Properties::new());
+
+    let doc = parse_query(
+        "UNWIND $rows AS r CREATE (:People {`User Id`: r.`User Id`, `First Name`: r.`First Name`})",
+    )
+    .unwrap();
+    let mut analyzer = Analyzer::new(&graph);
+    analyzer
+        .analyze(&doc)
+        .expect("UNWIND-bound row variable should allow any property key");
+}
+
+#[test]
+fn parameter_property_access_allowed_with_unknown_keys() {
+    // Parameters are runtime maps the analyzer can't introspect — keys
+    // on `$ctx.foo` must not be gated by the graph catalog either.
+    let mut graph = InMemoryGraph::new();
+    let _ = graph.create_node(vec!["Other".into()], Properties::new());
+
+    let doc = parse_query("RETURN $ctx.user_id AS u").unwrap();
+    let mut analyzer = Analyzer::new(&graph);
+    analyzer
+        .analyze(&doc)
+        .expect("property access on a parameter should skip the catalog check");
+}
+
 // --- Vector function analyzer tests ----------------------------------
 
 #[test]

{lora_python-0.12.0 → lora_python-0.13.0}/crates/lora-database/Cargo.toml

@@ -36,6 +36,7 @@ lora-compiler.workspace = true
 lora-executor = { workspace = true, default-features = false }
 lora-store.workspace = true
 lora-snapshot.workspace = true
+lora-io.workspace = true
 lora-wal.workspace = true
 
 serde_json.workspace = true

lora_python-0.13.0/crates/lora-database/src/io.rs

@@ -0,0 +1,338 @@
+//! Row-level bulk import / export driver.
+//!
+//! Thin orchestration on top of [`lora_io`]. Export drives the existing
+//! [`QueryStream`] through a [`lora_io::RowEncoder`]; import drives a
+//! [`lora_io::RowDecoder`] through batched
+//! `UNWIND $rows AS r CREATE …` statements either generated from a
+//! [`lora_io::RowMapping`] (auto-mapping path) or supplied verbatim by
+//! the caller (Cypher template escape hatch).
+
+use std::any::Any;
+use std::collections::BTreeMap;
+use std::io::{BufRead, Write};
+
+use lora_executor::{ExecuteOptions, LoraValue, QueryResult, ResultFormat};
+use lora_io::{
+    CsvDecoder, CsvEncoder, Format, JsonArrayDecoder, JsonArrayEncoder, JsonlDecoder, JsonlEncoder,
+    RowDecoder, RowEncoder, RowMapping,
+};
+use lora_store::{GraphStorage, GraphStorageMut, InMemoryGraph};
+
+use crate::error::{LoraError, LoraErrorCode};
+use crate::Database;
+
+/// Rows-shipped accounting from an export run.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub struct ExportStats {
+    pub rows: u64,
+}
+
+/// Rows-shipped accounting from an import run.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
+pub struct ImportStats {
+    pub rows: u64,
+    pub batches: u64,
+}
+
+/// Default batch size for [`Database::import_rows`] /
+/// [`Database::import_with_template`] when none is supplied. Sized to
+/// keep `$rows` parameter payloads roughly bounded for typical row widths.
+pub const DEFAULT_IMPORT_BATCH_SIZE: usize = 1_000;
+
+impl<S> Database<S>
+where
+    S: GraphStorage + GraphStorageMut + Any + Clone + Send + Sync + 'static,
+{
+    /// Encode a query's results into `writer`. Materialises the full
+    /// result set first (`RowArrays` projection) before encoding, so
+    /// peak memory is `O(result rows)`. Works on any storage backend.
+    ///
+    /// For the in-memory backend prefer
+    /// [`Database::export_query_streaming`], which pulls rows from
+    /// the engine's true streaming cursor and keeps peak memory
+    /// bounded by the encoder buffer.
+    pub fn export_query<W: Write>(
+        &self,
+        query: &str,
+        params: BTreeMap<String, LoraValue>,
+        format: Format,
+        writer: W,
+    ) -> Result<ExportStats, LoraError> {
+        match format {
+            Format::Jsonl => self.drive_export(query, params, JsonlEncoder::new(writer)),
+            Format::Json => self.drive_export(query, params, JsonArrayEncoder::new(writer)),
+            Format::Csv => self.drive_export(query, params, CsvEncoder::new(writer)),
+        }
+    }
+
+    fn drive_export<E: RowEncoder>(
+        &self,
+        query: &str,
+        params: BTreeMap<String, LoraValue>,
+        mut encoder: E,
+    ) -> Result<ExportStats, LoraError> {
+        // Use the RowArrays result format so we get plan-derived
+        // column ordering even when the result set is empty. The
+        // executor materializes rows once; we drive them through
+        // the encoder row-at-a-time so memory stays bounded by the
+        // result set, not by the on-disk output size.
+        let result = self.execute_with_params(
+            query,
+            Some(ExecuteOptions {
+                format: ResultFormat::RowArrays,
+            }),
+            params,
+        )?;
+        let QueryResult::RowArrays(arrays) = result else {
+            return Err(LoraError::new(
+                LoraErrorCode::Internal,
+                "expected RowArrays result for export".to_string(),
+            ));
+        };
+        encoder.begin(&arrays.columns).map_err(io_err)?;
+        let mut rows = 0u64;
+        for row_vals in arrays.rows {
+            let pairs: Vec<(String, LoraValue)> =
+                arrays.columns.iter().cloned().zip(row_vals).collect();
+            encoder.write_named_row(&pairs).map_err(io_err)?;
+            rows += 1;
+        }
+        encoder.finish().map_err(io_err)?;
+        Ok(ExportStats { rows })
+    }
+
+    /// Decode rows from `reader` and apply them to the graph via the
+    /// supplied [`RowMapping`]. The mapping renders a parameterised
+    /// `UNWIND $rows AS r CREATE …` template; rows are batched and
+    /// each batch executes as a single auto-committed statement.
+    pub fn import_rows<R: BufRead>(
+        &self,
+        reader: R,
+        format: Format,
+        mapping: &RowMapping,
+        batch_size: Option<usize>,
+    ) -> Result<ImportStats, LoraError> {
+        let template = mapping.to_cypher().map_err(|e| {
+            LoraError::new(
+                LoraErrorCode::InvalidParams,
+                format!("invalid row mapping: {e}"),
+            )
+        })?;
+        self.import_with_template(reader, format, &template, batch_size)
+    }
+
+    /// Decode rows from `reader` and execute `template` once per
+    /// batch with `$rows` bound to that batch's row objects. The
+    /// caller-supplied template is the escape hatch for the
+    /// auto-mapping path — anything Cypher can express is fair game.
+    pub fn import_with_template<R: BufRead>(
+        &self,
+        reader: R,
+        format: Format,
+        template: &str,
+        batch_size: Option<usize>,
+    ) -> Result<ImportStats, LoraError> {
+        let batch = batch_size.unwrap_or(DEFAULT_IMPORT_BATCH_SIZE).max(1);
+        match format {
+            Format::Jsonl => self.drive_import(template, JsonlDecoder::new(reader), batch),
+            Format::Json => self.drive_import(template, JsonArrayDecoder::new(reader), batch),
+            Format::Csv => self.drive_import(template, CsvDecoder::new(reader), batch),
+        }
+    }
+
+    fn drive_import<D: RowDecoder>(
+        &self,
+        template: &str,
+        mut decoder: D,
+        batch_size: usize,
+    ) -> Result<ImportStats, LoraError> {
+        // Eagerly read the header so format errors surface before any
+        // mutations happen.
+        decoder.header().map_err(io_err)?;
+
+        let mut stats = ImportStats::default();
+        let mut buf: Vec<LoraValue> = Vec::with_capacity(batch_size);
+
+        while let Some(cells) = decoder.next_row().map_err(io_err)? {
+            let row_map: BTreeMap<String, LoraValue> = cells.into_iter().collect();
+            buf.push(LoraValue::Map(row_map));
+            if buf.len() >= batch_size {
+                self.flush_batch(template, &mut buf, &mut stats)?;
+            }
+        }
+        if !buf.is_empty() {
+            self.flush_batch(template, &mut buf, &mut stats)?;
+        }
+        Ok(stats)
+    }
+
+    fn flush_batch(
+        &self,
+        template: &str,
+        buf: &mut Vec<LoraValue>,
+        stats: &mut ImportStats,
+    ) -> Result<(), LoraError> {
+        let batch = std::mem::take(buf);
+        let batch_len = batch.len() as u64;
+        let mut params = BTreeMap::new();
+        params.insert("rows".to_string(), LoraValue::List(batch));
+        self.execute_with_params(template, None, params)?;
+        stats.rows += batch_len;
+        stats.batches += 1;
+        Ok(())
+    }
+}
+
+fn io_err(err: std::io::Error) -> LoraError {
+    LoraError::with_source(LoraErrorCode::Io, format!("{err}"), err)
+}
+
+impl Database<InMemoryGraph> {
+    /// Stream a query's results through the chosen [`Format`] into
+    /// `writer` using the engine's true pull cursor.
+    ///
+    /// Where [`Database::export_query`] materialises the full result
+    /// set first (`RowArrays` projection), this variant pulls rows
+    /// row-at-a-time off [`Self::stream_with_params`] and feeds each
+    /// one to the encoder. Peak engine-side memory stays bounded by
+    /// the encoder's internal buffer — typically tens of KiB —
+    /// regardless of total row count.
+    ///
+    /// Specialised on [`InMemoryGraph`] because the true streaming
+    /// cursor lives on that impl block.
+    pub fn export_query_streaming<W: Write>(
+        &self,
+        query: &str,
+        params: BTreeMap<String, LoraValue>,
+        format: Format,
+        writer: W,
+    ) -> Result<ExportStats, LoraError> {
+        match format {
+            Format::Jsonl => self.drive_streaming_export(query, params, JsonlEncoder::new(writer)),
+            Format::Json => {
+                self.drive_streaming_export(query, params, JsonArrayEncoder::new(writer))
+            }
+            Format::Csv => self.drive_streaming_export(query, params, CsvEncoder::new(writer)),
+        }
+    }
+
+    fn drive_streaming_export<E: RowEncoder>(
+        &self,
+        query: &str,
+        params: BTreeMap<String, LoraValue>,
+        mut encoder: E,
+    ) -> Result<ExportStats, LoraError> {
+        let mut stream = self.stream_with_params(query, params)?;
+        let columns = stream.columns().to_vec();
+        encoder.begin(&columns).map_err(io_err)?;
+        let mut rows = 0u64;
+        while let Some(row) = stream.next_row().map_err(LoraError::from_anyhow)? {
+            encoder.write_row(&row).map_err(io_err)?;
+            rows += 1;
+        }
+        encoder.finish().map_err(io_err)?;
+        Ok(ExportStats { rows })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn round_trip_node_import_then_export() {
+        let db = Database::in_memory();
+
+        let csv = "name:string,age:int\nalice,30\nbob,25\n";
+        let mapping = RowMapping::Node {
+            label: "User".into(),
+            id_column: None,
+            id_property: None,
+            properties: vec![
+                lora_io::ColumnSpec::identity("name"),
+                lora_io::ColumnSpec::identity("age"),
+            ],
+        };
+        let stats = db
+            .import_rows(std::io::Cursor::new(csv), Format::Csv, &mapping, Some(10))
+            .unwrap();
+        assert_eq!(stats.rows, 2);
+        assert_eq!(stats.batches, 1);
+
+        let mut out = Vec::new();
+        let export = db
+            .export_query(
+                "MATCH (u:User) RETURN u.name AS name, u.age AS age ORDER BY name",
+                BTreeMap::new(),
+                Format::Jsonl,
+                &mut out,
+            )
+            .unwrap();
+        assert_eq!(export.rows, 2);
+        let text = std::str::from_utf8(&out).unwrap();
+        let lines: Vec<_> = text.lines().collect();
+        assert_eq!(lines.len(), 2);
+        assert!(lines[0].contains("\"alice\""));
+        assert!(lines[1].contains("\"bob\""));
+    }
+
+    /// Property names with spaces — e.g. `User Id` from a CSV header —
+    /// are backtick-quoted by `RowMapping::to_cypher` and must analyze
+    /// even when the graph already holds unrelated nodes. Regression
+    /// for the playground bug where the second batch raised
+    /// `unknown property `User Id``.
+    #[test]
+    fn import_handles_property_names_with_spaces_in_non_empty_graph() {
+        let db = Database::in_memory();
+        db.execute("CREATE (:Other {tag: 1})", None).unwrap();
+
+        let csv = "User Id,First Name\nu1,Alice\nu2,Bob\nu3,Carol\n";
+        let mapping = RowMapping::Node {
+            label: "People".into(),
+            id_column: None,
+            id_property: None,
+            properties: vec![
+                lora_io::ColumnSpec::identity("User Id"),
+                lora_io::ColumnSpec::identity("First Name"),
+            ],
+        };
+        let stats = db
+            .import_rows(std::io::Cursor::new(csv), Format::Csv, &mapping, Some(2))
+            .expect("import with quoted property names should succeed");
+        assert_eq!(stats.rows, 3);
+        assert!(stats.batches >= 2, "expected at least 2 batches");
+    }
+
+    #[test]
+    fn cypher_template_import() {
+        let db = Database::in_memory();
+        let jsonl = "{\"name\":\"alice\",\"age\":30}\n{\"name\":\"bob\",\"age\":25}\n";
+        let stats = db
+            .import_with_template(
+                std::io::Cursor::new(jsonl),
+                Format::Jsonl,
+                "UNWIND $rows AS r CREATE (:Person {name: r.name, age: r.age})",
+                Some(50),
+            )
+            .unwrap();
+        assert_eq!(stats.rows, 2);
+
+        let res = db
+            .execute(
+                "MATCH (p:Person) RETURN count(p) AS c",
+                Some(ExecuteOptions {
+                    format: ResultFormat::RowArrays,
+                }),
+            )
+            .unwrap();
+        match res {
+            QueryResult::RowArrays(r) => {
+                let LoraValue::Int(c) = &r.rows[0][0] else {
+                    panic!("expected Int");
+                };
+                assert_eq!(*c, 2);
+            }
+            other => panic!("unexpected result {other:?}"),
+        }
+    }
+}