Struct RuntimeContext 

pub struct RuntimeContext<P>
where
    P: Pager<Blob = EntryHandle> + Send + Sync,
{ /* private fields */ }

In-memory execution context shared by plan-based queries.

Important: “lazy loading” here refers to table metadata only (schema, executor-side column descriptors, and a small next-row-id counter). We do NOT eagerly load or materialize the table’s row data into memory. All row/column data remains on the ColumnStore and is streamed in chunks during query execution. This keeps the memory footprint low even for very large tables.

Typical resource usage:

• Metadata per table: ~100s of bytes to a few KB (schema + field ids)
• ExecutorTable struct: small (handles + counters)
• Actual table rows: streamed from disk in chunks (never fully resident)

Implementations

impl<P> RuntimeContext<P>

where P: Pager<Blob = EntryHandle> + Send + Sync + 'static,

pub fn new(pager: Arc<P>) -> Self

pub fn txn_manager(&self) -> Arc<TxnIdManager>

Return the transaction ID manager shared with sessions.

pub fn persist_next_txn_id(&self, next_txn_id: TxnId) -> Result<()>

Persist the next_txn_id to the catalog.

pub fn default_snapshot(&self) -> TransactionSnapshot

Construct the default snapshot for auto-commit operations.

pub fn create_session(self: &Arc<Self>) -> RuntimeSession<P>

Create a new session for transaction management. Each session can have its own independent transaction.

pub fn table(self: &Arc<Self>, name: &str) -> Result<RuntimeTableHandle<P>>

Get a handle to an existing table by name.

pub fn has_active_transaction(&self) -> bool

👎Deprecated: Use session-based transactions instead

Check if there’s an active transaction (legacy - checks if ANY session has a transaction).

pub fn create_table<C, I>( self: &Arc<Self>, name: &str, columns: I, ) -> Result<RuntimeTableHandle<P>>

where C: IntoColumnSpec, I: IntoIterator<Item = C>,

pub fn create_table_if_not_exists<C, I>( self: &Arc<Self>, name: &str, columns: I, ) -> Result<RuntimeTableHandle<P>>

where C: IntoColumnSpec, I: IntoIterator<Item = C>,

pub fn create_table_plan( &self, plan: CreateTablePlan, ) -> Result<RuntimeStatementResult<P>>

pub fn table_names(self: &Arc<Self>) -> Vec<String>

pub fn create_table_builder( &self, name: &str, ) -> RuntimeCreateTableBuilder<'_, P>

pub fn table_column_specs( self: &Arc<Self>, name: &str, ) -> Result<Vec<ColumnSpec>>

pub fn export_table_rows(self: &Arc<Self>, name: &str) -> Result<RowBatch>

pub fn insert(&self, plan: InsertPlan) -> Result<RuntimeStatementResult<P>>

pub fn insert_with_snapshot( &self, plan: InsertPlan, snapshot: TransactionSnapshot, ) -> Result<RuntimeStatementResult<P>>

pub fn get_batches_with_row_ids( &self, table_name: &str, filter: Option<LlkvExpr<'static, String>>, ) -> Result<Vec<RecordBatch>>

Get raw batches from a table including row_ids, optionally filtered. This is used for transaction seeding where we need to preserve existing row_ids.

pub fn get_batches_with_row_ids_with_snapshot( &self, table_name: &str, filter: Option<LlkvExpr<'static, String>>, snapshot: TransactionSnapshot, ) -> Result<Vec<RecordBatch>>

pub fn append_batches_with_row_ids( &self, table_name: &str, batches: Vec<RecordBatch>, ) -> Result<usize>

Append batches directly to a table, preserving row_ids from the batches. This is used for transaction seeding where we need to preserve existing row_ids.

pub fn update(&self, plan: UpdatePlan) -> Result<RuntimeStatementResult<P>>

pub fn update_with_snapshot( &self, plan: UpdatePlan, snapshot: TransactionSnapshot, ) -> Result<RuntimeStatementResult<P>>

pub fn delete(&self, plan: DeletePlan) -> Result<RuntimeStatementResult<P>>

pub fn delete_with_snapshot( &self, plan: DeletePlan, snapshot: TransactionSnapshot, ) -> Result<RuntimeStatementResult<P>>

pub fn table_handle( self: &Arc<Self>, name: &str, ) -> Result<RuntimeTableHandle<P>>

pub fn execute_select( self: &Arc<Self>, plan: SelectPlan, ) -> Result<SelectExecution<P>>

pub fn execute_select_with_snapshot( self: &Arc<Self>, plan: SelectPlan, snapshot: TransactionSnapshot, ) -> Result<SelectExecution<P>>

pub fn drop_table_immediate(&self, name: &str, if_exists: bool) -> Result<()>

pub fn is_table_marked_dropped(&self, canonical_name: &str) -> bool