Struct ExecutionContext 

pub struct ExecutionContext<'a> {
    pub catalog: &'a mut Catalog,
    /* private fields */
}

Shared state threaded through every physical operator during execution. Exposes MVCC helpers, storage access, expression evaluation and DDL utilities.

Fields

catalog: &'a mut Catalog

Mutable reference to the global catalog (schema + metadata).

Implementations

impl<'a> ExecutionContext<'a>

pub fn new( catalog: &'a mut Catalog, txn: &'a mut Transaction, txn_mgr: &'a TransactionManager, storage: Arc<dyn StorageEngine>, ) -> Self

pub fn command_id(&self) -> CommandId

pub fn snapshot(&self) -> &TransactionSnapshot

pub fn is_visible(&self, meta: &TupleMeta) -> bool

pub fn read_visible_tuple( &mut self, table: &TableReference, rid: RecordId, meta: &TupleMeta, tuple: Tuple, ) -> QuillSQLResult<Option<Tuple>>

Perform MVCC visibility checks (and shared locks) based on the current isolation level, returning the tuple only if it is visible.

pub fn eval_predicate(&self, expr: &Expr, tuple: &Tuple) -> QuillSQLResult<bool>

Evaluate an expression expected to produce a boolean result.

pub fn eval_expr( &self, expr: &Expr, tuple: &Tuple, ) -> QuillSQLResult<ScalarValue>

Evaluate an arbitrary scalar expression.

pub fn insert_tuple_with_indexes( &mut self, table: &TableReference, tuple: &Tuple, ) -> QuillSQLResult<()>

Insert a tuple, update all indexes, and register undo state.

pub fn apply_delete( &mut self, table_heap: Arc<TableHeap>, rid: RecordId, prev_meta: TupleMeta, prev_tuple: Tuple, ) -> QuillSQLResult<()>

Mark a row deleted via MVCC and enqueue undo data.

pub fn apply_update( &mut self, table: &TableReference, table_heap: Arc<TableHeap>, rid: RecordId, new_tuple: Tuple, prev_meta: TupleMeta, prev_tuple: Tuple, ) -> QuillSQLResult<()>

Create a new MVCC version, update indexes, and log undo.

pub fn prepare_row_for_write( &mut self, table: &TableReference, rid: RecordId, table_heap: &Arc<TableHeap>, observed_meta: &TupleMeta, ) -> QuillSQLResult<Option<(TupleMeta, Tuple)>>

Acquire an exclusive lock and re-check visibility before mutating a row. Returns the current tuple version if it is still visible.

pub fn lock_table( &mut self, table: TableReference, mode: LockMode, ) -> QuillSQLResult<()>

pub fn lock_row_shared( &mut self, table: &TableReference, rid: RecordId, retain: bool, ) -> QuillSQLResult<()>

pub fn unlock_row_shared( &mut self, table: &TableReference, rid: RecordId, ) -> QuillSQLResult<()>

pub fn lock_row_exclusive( &mut self, table: &TableReference, rid: RecordId, ) -> QuillSQLResult<()>

pub fn ensure_writable( &self, table: &TableReference, operation: &str, ) -> QuillSQLResult<()>

Ensure that the current transaction is allowed to perform a write on the given table.

pub fn txn(&self) -> &Transaction

pub fn txn_mut(&mut self) -> &mut Transaction

pub fn txn_manager(&self) -> &TransactionManager

pub fn txn_runtime(&self) -> &TxnRuntime<'a>

pub fn txn_id(&self) -> TransactionId

pub fn unlock_row(&self, table: &TableReference, rid: RecordId)

pub fn table_heap( &self, table: &TableReference, ) -> QuillSQLResult<Arc<TableHeap>>

Look up the table heap through the storage engine.

pub fn table_indexes( &self, table: &TableReference, ) -> QuillSQLResult<Vec<Arc<BPlusTreeIndex>>>

Fetch all indexes defined on a table.

pub fn try_table_heap(&self, table: &TableReference) -> Option<Arc<TableHeap>>

Non-allocating helper used by DDL to test for table existence.

pub fn create_table( &mut self, table: TableReference, schema: Arc<Schema>, ) -> QuillSQLResult<()>

Create a table (used by the CREATE TABLE physical operator).

pub fn drop_table(&mut self, table: &TableReference) -> QuillSQLResult<bool>

Drop a table, returning whether it existed.

pub fn create_index( &mut self, name: String, table: &TableReference, key_schema: Arc<Schema>, ) -> QuillSQLResult<()>

Create an index (used by CREATE INDEX).

pub fn drop_index( &mut self, table: &TableReference, name: &str, ) -> QuillSQLResult<bool>

Drop an index, returning whether it existed.

pub fn find_index_owner( &self, catalog: Option<&str>, schema: Option<&str>, name: &str, ) -> Option<TableReference>

Resolve the table that owns catalog.schema.index.