Struct MongrelSession 

pub struct MongrelSession { /* private fields */ }

Convenience wrapper: a DataFusion SessionContext bound to a live MongrelDB, with a result cache keyed by (sql, snapshot_epoch) that auto-invalidates when a commit advances the epoch.

Implementations

impl MongrelSession

pub fn new(db: Table) -> Self

Create a session over a live Table. Takes ownership; wrap in Arc if you need to keep a handle for writes after registering the provider. Registers the ann_search UDF so SQL semantic-search predicates parse.

pub fn new_with_external_modules( db: Table, modules: impl IntoIterator<Item = Arc<dyn ExternalTableModule>>, ) -> Result<Self>

pub fn open(database: Arc<Database>) -> Result<Self>

Open a session over a multi-table Database (spec §12). Auto-registers every live table as a MongrelProvider; the cache epoch is driven by Database::visible_epoch() so any table’s commit invalidates cached results.

pub fn open_with_external_modules( database: Arc<Database>, modules: impl IntoIterator<Item = Arc<dyn ExternalTableModule>>, ) -> Result<Self>

pub fn register_external_module( &self, module: Arc<dyn ExternalTableModule>, ) -> Result<()>

pub fn db(&self) -> Option<&Arc<Mutex<Table>>>

The underlying Table handle (Phase 19.3: used by the daemon for direct put/delete/commit/count access). Returns None when the session was opened over an empty Database.

pub fn create_view(&self, name: &str, sql: &str)

Phase 17.3: create a named materialized view backed by a SQL query. SELECT * FROM <name> resolves to the view’s defining SQL, which is executed (or served from the result cache) transparently. The view is automatically invalidated on commit (via the epoch-keyed result cache).

pub fn drop_view(&self, name: &str)

Drop a named materialized view.

pub async fn register(&self, name: &str) -> Result<()>

Register the table under name so select * from <name> resolves.

pub async fn register_db(&self, name: &str, db: Table) -> Result<()>

Register a second (or further) live Table as another table on the same session, enabling cross-table SQL joins. The first Table (passed to Self::new) still owns the result-cache epoch: cached results are invalidated on its commits, so mutate the primary table last or call Self::clear_cache after writing a secondary table.

pub async fn run(&self, sql: &str) -> Result<Vec<RecordBatch>>

Run a SQL statement: DDL/commands are intercepted; otherwise a result cache keyed by (normalized SQL, snapshot epoch) memoizes batches. §5.3: simple single-table SELECTs are served by [try_direct_dispatch] (no DataFusion planning) before falling back to the full DataFusion path.

pub async fn run_sql_traced( &self, sql: &str, ) -> Result<(Vec<RecordBatch>, QueryTrace)>

Self::run with a captured mongreldb_core::trace::QueryTrace.

Runs the SQL query inside a trace-capture scope so that path-decision recordings from both the SQL scan layer (MongrelProvider::scan) and the core engine (Table::native_page_cursor, query_columns_native, count_conditions, etc.) are collected into a single returned trace.

The session-level result cache returns before scan() runs on a hit, so a session-cache hit yields scan_mode = Unknown. For scan-level result-cache tracing, use mongreldb_core::Table::query_columns_native_cached_traced.

pub fn clear_cache(&self)

Drop all cached results (e.g. after a manual data change you want reflected immediately).

pub fn context(&self) -> &SessionContext

pub fn register_scalar_udf(&self, f: ScalarUDF)

Register a custom scalar SQL function on this session.

This is the Rust escape hatch for application-defined SQL functions. The session’s plan and result caches are cleared because function resolution can change query output without advancing the storage epoch.

pub fn register_aggregate_udf(&self, f: AggregateUDF)

Register a custom aggregate SQL function on this session.

pub fn register_window_udf(&self, f: WindowUDF)

Register a custom window SQL function on this session.