Struct TestEngine 

pub struct TestEngine { /* private fields */ }

Implementations

impl TestEngine

pub fn new() -> Self

Create a new TestEngine with all subsystems (CDC, metrics, etc.).

pub fn builder() -> TestEngineBuilder

Start configuring a test engine via the builder.

pub fn admin(&self, rql: &str) -> Vec<Frame>

Run an admin RQL statement as system identity. Panics on error.

pub fn command(&self, rql: &str) -> Vec<Frame>

Run a command RQL statement as system identity. Panics on error.

pub fn query(&self, rql: &str) -> Vec<Frame>

Run a query RQL statement as system identity. Panics on error.

pub fn admin_err(&self, rql: &str) -> String

Run an admin statement expecting an error. Panics if it succeeds.

pub fn command_err(&self, rql: &str) -> String

Run a command statement expecting an error. Panics if it succeeds.

pub fn query_err(&self, rql: &str) -> String

Run a query statement expecting an error. Panics if it succeeds.

pub fn row_count(frames: &[Frame]) -> usize

Count rows in the first frame.

pub fn identity() -> IdentityId

Return the system identity used by this harness.

pub fn inner(&self) -> &StandardEngine

Access the underlying StandardEngine.

Methods from Deref<Target = StandardEngine>

pub fn begin_command(&self, identity: IdentityId) -> Result<CommandTransaction>

pub fn begin_admin(&self, identity: IdentityId) -> Result<AdminTransaction>

pub fn begin_query(&self, identity: IdentityId) -> Result<QueryTransaction>

pub fn begin_subscription( &self, identity: IdentityId, ) -> Result<SubscriptionTransaction>

pub fn admin_as( &self, identity: IdentityId, rql: &str, params: Params, ) -> Result<Vec<Frame>>

pub fn command_as( &self, identity: IdentityId, rql: &str, params: Params, ) -> Result<Vec<Frame>>

pub fn query_as( &self, identity: IdentityId, rql: &str, params: Params, ) -> Result<Vec<Frame>>

pub fn subscription_as( &self, identity: IdentityId, rql: &str, params: Params, ) -> Result<Vec<Frame>>

pub fn procedure_as( &self, identity: IdentityId, name: &str, params: Params, ) -> Result<Vec<Frame>>

Call a procedure by fully-qualified name.

pub fn register_virtual_table<T: UserVTable>( &self, namespace: &str, name: &str, table: T, ) -> Result<VTableId>

Register a user-defined virtual table.

The virtual table will be available for queries using the given namespace and name.

Arguments

• namespace - The namespace name (e.g., “default”, “my_namespace”)
• name - The table name
• table - The virtual table implementation

Returns

The assigned VTableId on success.

Example

use reifydb_engine::vtable::{UserVTable, UserVTableColumn};
use reifydb_type::value::r#type::Type;
use reifydb_core::value::Columns;

#[derive(Clone)]
struct MyTable;

impl UserVTable for MyTable {
    fn definition(&self) -> Vec<UserVTableColumn> {
        vec![UserVTableColumn::new("id", Type::Uint8)]
    }
    fn get(&self) -> Columns {
        // Return column-oriented data
        Columns::empty()
    }
}

let id = engine.register_virtual_table("default", "my_table", MyTable)?;

pub fn create_interceptors(&self) -> Interceptors

Create a new set of interceptors from the factory.

pub fn add_interceptor_factory( &self, factory: Arc<dyn Fn(&mut Interceptors) + Send + Sync>, )

Register an additional interceptor factory function.

The function will be called on every create() to augment the base interceptors. This is thread-safe and can be called after the engine is constructed (e.g. by subsystems).

pub fn begin_query_at_version( &self, version: CommitVersion, identity: IdentityId, ) -> Result<QueryTransaction>

Begin a query transaction at a specific version.

This is used for parallel query execution where multiple tasks need to read from the same snapshot (same CommitVersion) for consistency.

pub fn multi(&self) -> &MultiTransaction

pub fn multi_owned(&self) -> MultiTransaction

pub fn actor_system(&self) -> ActorSystem

Get the actor system

pub fn single(&self) -> &SingleTransaction

pub fn single_owned(&self) -> SingleTransaction

pub fn emit<E: Event>(&self, event: E)

pub fn materialized_catalog(&self) -> &MaterializedCatalog

pub fn catalog(&self) -> Catalog

Returns a Catalog instance for catalog lookups. The Catalog provides three-tier lookup methods that check transactional changes, then MaterializedCatalog, then fall back to storage.

pub fn flow_operator_store(&self) -> &SystemFlowOperatorStore

pub fn current_version(&self) -> Result<CommitVersion>

Get the current version from the transaction manager

pub fn done_until(&self) -> CommitVersion

Returns the highest version where ALL prior versions have completed. This is useful for CDC polling to know the safe upper bound for fetching CDC events - all events up to this version are guaranteed to be in storage.

pub fn wait_for_mark_timeout( &self, version: CommitVersion, timeout: Duration, ) -> bool

Wait for the watermark to reach the given version with a timeout. Returns true if the watermark reached the target, false if timeout occurred.

pub fn executor(&self) -> Executor

pub fn cdc_store(&self) -> CdcStore

Get the CDC store from the IoC container.

Returns the CdcStore that was registered during engine construction. Panics if CdcStore was not registered.

pub fn shutdown(&self)

pub fn bulk_insert<'e>( &'e self, identity: IdentityId, ) -> BulkInsertBuilder<'e, Validated>

Start a bulk insert operation with full validation.

This provides a fluent API for fast bulk inserts that bypasses RQL parsing. All inserts within a single builder execute in one transaction.

Example

use reifydb_type::params;

engine.bulk_insert(&identity)
    .table("namespace.users")
        .row(params!{ id: 1, name: "Alice" })
        .row(params!{ id: 2, name: "Bob" })
        .done()
    .execute()?;

pub fn bulk_insert_trusted<'e>( &'e self, identity: IdentityId, ) -> BulkInsertBuilder<'e, Trusted>

Start a bulk insert operation with validation disabled (trusted mode).

Use this for pre-validated internal data where constraint validation can be skipped for maximum performance.

Safety

The caller is responsible for ensuring the data conforms to the schema constraints. Invalid data may cause undefined behavior.

Trait Implementations

impl Deref for TestEngine

type Target = StandardEngine

The resulting type after dereferencing.

fn deref(&self) -> &StandardEngine

Dereferences the value.