Struct Transaction 

pub struct Transaction<'a> { /* private fields */ }

A kit transaction.

Implementations

impl<'a> Transaction<'a>

pub fn insert(&mut self, table: &str, row: Map<String, Value>) -> Result<Row>

Insert a row into table.

pub fn insert_returning( &mut self, table: &str, row: Map<String, Value>, returning: Vec<String>, ) -> Result<Value>

pub fn insert_many( &mut self, table: &str, rows: Vec<Map<String, Value>>, ) -> Result<Vec<Row>>

Insert many rows into table within this single transaction.

Each row still passes through defaults, validation, and constraint checks, but the whole batch is staged in one transaction (the caller commits once) — far faster than a row-at-a-time begin/commit loop for bulk loads. For a single-column primary key the existing primary keys are loaded once into a set so the per-row duplicate check stays O(1) instead of re-scanning the table for every row. Mirrors the TypeScript kit’s insertInto().valuesMany.

pub fn update( &mut self, table: &str, pk: &Value, patch: Map<String, Value>, ) -> Result<Row>

Update the row in table identified by pk with patch.

pub fn delete(&mut self, table: &str, pk: &Value) -> Result<()>

Delete the row in table identified by pk.

pub fn truncate(&mut self, table: &str) -> Result<()>

pub fn upsert( &mut self, table: &str, row: Map<String, Value>, on_conflict: OnConflict, returning: Vec<String>, ) -> Result<Value>

pub fn update_where( &mut self, table: &str, filter: Option<Expr>, patch: Map<String, Value>, returning: Vec<String>, ) -> Result<Vec<Value>>

pub fn delete_where( &mut self, table: &str, filter: Option<Expr>, returning: Vec<String>, ) -> Result<Vec<Value>>

pub fn get_by_pk(&self, table: &str, pk: &Value) -> Result<Option<Row>>

Read a row by primary key.

pub fn select(&self, query: &Query) -> Result<Vec<Row>>

Execute a Select query. Subqueries (IN (subquery), EXISTS) and like/contains/not in predicates resolve against this transaction’s read snapshot, so they may reference other tables.

pub fn select_distinct(&self, query: &Query) -> Result<Vec<Row>>

Like select but drops duplicate rows. When the select projects columns, duplicates are decided on the projection (true SELECT DISTINCT col, ...); otherwise on the whole row.

pub fn select_with(&self, ctes: &[Cte], body: &Select) -> Result<Vec<Row>>

Materialize each CTE in order (a later CTE may read an earlier one) and run body with those named results available as virtual tables.

pub fn aggregate(&self, query: &AggregateQuery) -> Result<Vec<Row>>

Run an aggregate / group-by / having query. Returns one row per group (group-key columns plus the aggregate aliases); with no group_by the whole filtered table is a single group.

pub fn join(&self, query: &JoinQuery) -> Result<Vec<JoinRow>>

Run a nested-loop join. Each result row is a map keyed by table alias; see JoinQuery for the shape. Supports inner, left, and cross joins.

pub fn ann_search( &self, table: &str, column: &str, query: Vec<f32>, k: usize, ) -> Result<Vec<Row>>

Approximate nearest-neighbour search: return the k rows whose Embedding column is closest to query, resolved by the column’s ANN (HNSW) index. Requires an Ann index on column. Results are the top-k survivor rows (as a set — distance ranking is not currently surfaced).

pub fn sparse_match( &self, table: &str, column: &str, query: Vec<(u32, f32)>, k: usize, ) -> Result<Vec<Row>>

Learned-sparse (SPLADE-style) retrieval: return the k rows whose Sparse column best matches the weighted query tokens query ((token_id, weight) pairs), resolved by the column’s sparse index. Requires a Sparse index on column.

pub fn execute(&mut self, query: &Query) -> Result<Vec<Value>>

pub fn commit(self) -> Result<()>

Commit the transaction.

A transaction that staged a large batch on some table (typically via Self::insert_many) flushes that table afterward. Without this, a committed-but-unflushed batch exists only as WAL records: every subsequent Database::open (there is no warm/daemon mode for the CLI, and any short-lived process pays this on every invocation) must fully replay and re-index the whole batch just to open the table, which is far more expensive than the one-time flush. Below the threshold this is a no-op cost (the loop below runs over self.staged, already in memory) so ordinary interactive transactions are unaffected.

pub fn rollback(self)

Roll back the transaction.

pub fn all_rows(&self, table: &str) -> Result<Vec<Row>>

All rows of table visible to this transaction (staged writes included).