`mini\Database\VirtualDatabase` class

Show private and protected members

Documentation

Virtual database that executes SQL against registered TableInterface instances

Implements DatabaseInterface to provide a drop-in replacement for PDODatabase when working with in-memory table data structures.

Phase 1: Single-table operations

SELECT with WHERE, ORDER BY, LIMIT, column projection
INSERT, UPDATE, DELETE on MutableTableInterface
Subqueries in IN clauses: WHERE col IN (SELECT ...)

Future phases will add JOINs, aggregates, DISTINCT, correlated subqueries.

Usage:

$vdb = new VirtualDatabase();
$vdb->registerTable('users', $usersTable);
$vdb->registerTable('orders', $ordersTable);

// SELECT queries return ResultSetInterface
foreach ($vdb->query('SELECT name, email FROM users WHERE status = ?', ['active']) as $row) {
    echo $row->name;
}

// INSERT/UPDATE/DELETE return affected row count
$affected = $vdb->exec('DELETE FROM users WHERE id = ?', [123]);

Inheritance

Implements: mini\Database\DatabaseInterface

Properties (12)

private array $tables

private array $aggregates

private mini\Database\ExpressionEvaluator $evaluator

private mini\Database\AstOptimizer $optimizer

private static ?ReflectionProperty $astProperty

Reflection accessors for PartialQuery to avoid cloning overhead

private static ?ReflectionMethod $ensureAstMethod

private ?string $lastInsertId

Last insert ID from most recent INSERT

private WeakMap $queryMap

private ?float $queryTimeout

Maximum query execution time in seconds (null = no limit)

private ?float $queryStartTime

Query start time for timeout tracking

private string $tableClass

Table class to use for CREATE TABLE (InMemoryTable or ArrayTable)

private ?mini\Database\Session $currentSession

Current session for temp table resolution (set during query execution)

Methods (149)

public `__construct()`

Documentation missing

public `createAggregate()`

public `isAggregate()`

Check if a function name is a registered aggregate

public `setQueryTimeout()`

Set maximum query execution time in seconds

public `useArrayTable()`

Use ArrayTable instead of InMemoryTable for CREATE TABLE

public `session()`

Create a new session for this database

public `queryWithSession()`

Execute a SELECT query with session context

public `execWithSession()`

Execute an INSERT/UPDATE/DELETE/DDL with session context

private `checkTimeout()`

Check if current query has exceeded timeout

private `hasAggregates()`

Check if SELECT columns contain any aggregate function calls

private `expressionHasAggregate()`

Recursively check if an expression contains an aggregate function

private `hasWindowFunctions()`

Check if any column contains a window function

private `expressionHasWindowFunction()`

Recursively check if an expression contains a window function

private `registerBuiltinAggregates()`

public `registerTable()`

public `getTable()`

Get a registered table by name

public `getTableNames()`

Get all registered table names

public `withTables()`

Create a new VirtualDatabase with shadowed tables

public `query()`

Execute a SELECT query

private `wrapQuery()`

Wrap a PartialQuery in a Query and register the mapping

private `unwrapQuery()`

Get the underlying PartialQuery for a Query instance

private static `peekAst()`

Get AST from PartialQuery without cloning using reflection

private `rawExecutor()`

Get a raw query executor closure for PartialQuery

private `wrapWithTimeout()`

Wrap an iterable with timeout checking

private `timeoutGenerator()`

Generator that checks for timeout every 100 rows

private `rawExecutorWithSession()`

Create raw executor closure with session context

private `executeInsertWithSession()`

Execute INSERT with session context

private `executeUpdateWithSession()`

Execute UPDATE with session context

private `executeDeleteWithSession()`

Execute DELETE with session context

private `executeCreateTableWithSession()`

Execute CREATE TABLE with session context

private `executeDropTableWithSession()`

Execute DROP TABLE with session context

public `exec()`

Execute an INSERT, UPDATE, DELETE, or DDL statement

public `queryOne()`

{@inheritdoc}

public `queryField()`

{@inheritdoc}

public `queryColumn()`

{@inheritdoc}

public `lastInsertId()`

{@inheritdoc}

public `tableExists()`

{@inheritdoc}

public `transaction()`

{@inheritdoc}

public `getDialect()`

{@inheritdoc}

public `quote()`

{@inheritdoc}

public `quoteIdentifier()`

{@inheritdoc}

public `delete()`

{@inheritdoc}

public `update()`

{@inheritdoc}

public `insert()`

{@inheritdoc}

public `upsert()`

{@inheritdoc}

public `getSchema()`

{@inheritdoc}

private `executeUnionAsTable()`

Execute a UNION query as TableInterface

private `intersectTables()`

INTERSECT: rows that exist in both tables

private `exceptTables()`

EXCEPT: rows from left that don't exist in right

private `executeUnionBranchAsTable()`

Execute a branch of a UNION as TableInterface

private `executeWithStatement()`

Execute a WITH statement (CTE)

private `isCteRecursive()`

Check if a CTE references itself (is recursive)

private `astReferencesTable()`

Check if an AST node references a specific table name

private `executeRecursiveCte()`

Execute a recursive CTE

private `renameRowColumns()`

Rename row columns to match expected column names

private `executeCteQuery()`

Execute a CTE query and return as TableInterface

private `rowsToTable()`

Convert stdClass rows to InMemoryTable

private `renameCteColumns()`

Rename CTE table columns according to specified column list

private `executeSelect()`

Documentation missing

private `executeWindowSelect()`

Execute a SELECT with window functions

private `collectWindowFunctions()`

Collect window functions from SELECT columns

private `extractWindowFunctions()`

Extract all WindowFunctionNode instances from an expression

private `generateWindowFuncAlias()`

Generate a unique alias for a window function

private `computeWindowFunction()`

Compute window function values for all rows

private `computePartitionKey()`

Compute partition key from PARTITION BY expressions

private `compareRowsForWindowOrderBy()`

Compare two rows for window ORDER BY

private `evaluateWindowFunctionForPartition()`

Evaluate window function for a sorted partition

private `projectRowWithWindowValues()`

Project a row with window function values

private `evaluateExpressionWithWindowValues()`

Evaluate expression, substituting window function results

private `compareRowsForOrderBy()`

Compare two rows for ORDER BY (for result sorting)

private `executeAggregateSelect()`

Execute an aggregate SELECT (e.g., SELECT COUNT(*), SUM(price) FROM orders)

private `executeSimpleAggregate()`

Execute aggregate without GROUP BY (single group containing all rows)

private `executeGroupByAggregate()`

Execute aggregate with GROUP BY

private `cloneAggregateInfos()`

Clone aggregate infos with fresh contexts for a new group

private `stepAggregates()`

Step all aggregates with values from a row

private `buildAggregateResultRow()`

Build result row from finalized aggregates and non-aggregate columns

private `collectNonAggregateColumns()`

Collect non-aggregate columns from SELECT

private `sortResults()`

Sort result rows by ORDER BY specification

private `sortResultsWithOriginal()`

Sort results that include both projected and original row data

private `collectAggregateInfos()`

Collect aggregate function info from SELECT columns

private `executeSelectAsTable()`

Execute a SELECT and return as TableInterface (for subqueries)

private `executeSelectWithPredicatePushdown()`

Execute SELECT with CROSS JOINs using predicate pushdown optimization

private `flattenAndPredicates()`

Flatten an AND-connected expression into a list of predicates

private `findTablesInPredicate()`

Find which tables are referenced in a predicate

private `tryExtractEquiJoin()`

Try to extract equi-join columns from a predicate

private `resolveColumnWithTable()`

Resolve a column identifier to its fully qualified name (table.column)

private `collectTableReferences()`

Recursively collect table references from an expression

private `rebuildAndExpression()`

Rebuild an AND expression from a list of predicates

private `executeSubqueryAsSet()`

Execute a subquery and return as SetInterface for IN clause

private `executeDerivedTable()`

Execute a derived table (subquery in FROM position)

private `inferColumnsFromSelect()`

Infer column definitions from a SELECT statement (for empty derived tables)

private `executeSubqueryWithContext()`

Execute a subquery with outer row context for correlated subqueries

private `executeAggregateOnRows()`

Execute aggregate query on pre-filtered rows

private `extractColumnNames()`

Extract simple column names from SELECT columns

private `applyExistsToTable()`

Apply EXISTS operation to table

private `findOuterReferences()`

Find outer references in a subquery WHERE clause

private `collectOuterReferences()`

Recursively collect outer references from AST node

private `hasOrWithOuterReferences()`

Check if WHERE clause contains OR with outer references

private `nodeReferencesTable()`

Check if AST node references a specific table

private `tryApplyExistsWithExistsTable()`

Try to apply correlated EXISTS using ExistsTable (hash-based, much faster)

private `findMatchingColumn()`

Find a column in the table's columns, handling qualified/unqualified names

private `parseColumnReference()`

Parse a column reference to determine if it's inner or outer table

private `predicateReferencesColumn()`

Check if a predicate references a specific column

private `applyCorrelatedExistsRowByRow()`

Apply correlated EXISTS using row-by-row evaluation

private `evaluateCorrelatedExists()`

Evaluate correlated EXISTS by iterating subquery table and testing WHERE

private `evaluateWhereWithContext()`

Evaluate WHERE expression with row data and outer context

private `evaluateExprWithContext()`

Evaluate expression value with row data and outer context

private `buildCorrelatedTemplate()`

Build a Table template with binds for outer references

private `applyWhereWithBinds()`

Apply WHERE clause, converting outer references to binds

private `projectRow()`

Project a row to only the requested columns

private `executeInsert()`

Documentation missing

private `executeInsertSelect()`

Execute INSERT INTO ... SELECT ... statement

private `findPrimaryKeyColumn()`

Find the primary key column name for a table

private `deleteExistingRow()`

Delete a row by primary key value (for REPLACE)

private `executeUpdate()`

Documentation missing

private `expressionNeedsRowContext()`

Check if an expression contains column references (needs row context to evaluate)

private `executeUpdateWithRowContext()`

Execute UPDATE with row-by-row evaluation for self-referencing expressions

private `executeDelete()`

Documentation missing

private `executeCreateTable()`

Execute CREATE TABLE - creates a table with the given schema

private `executeDropTable()`

Execute DROP TABLE - removes a registered table

private `astColumnToColumnDef()`

Convert AST ColumnDefinition to ColumnDef

private `sqlTypeToColumnType()`

Map SQL data type string to ColumnType enum

private `applyWhereToTableInterface()`

Apply a WHERE clause AST to a TableInterface using table methods

private `canPushPredicate()`

Check if a predicate can be pushed to the table interface

private `applySinglePredicate()`

Apply a single pushable predicate to the table

private `filterByExpression()`

Filter table rows by evaluating an expression against each row

private `applyInWithIndexAwareness()`

Apply IN filter with index-aware optimization

private `applyQuantifiedComparison()`

Apply ALL/ANY quantified comparison

private `compareAll()`

Check if comparison is true for ALL values (ALL quantifier)

private `compareAny()`

Check if comparison is true for at least one value (ANY quantifier)

private `compare()`

Perform a single comparison

private `trySimplifyArithmeticComparison()`

Try to simplify arithmetic comparison to pushable form

private `solveForColumn()`

Solve for column in arithmetic comparison

private `flipComparisonOp()`

Flip comparison operator (for negative multiplier or subtraction from constant)

private `expressionContainsNull()`

Check if an arithmetic expression contains NULL literal

private `buildPredicateFromAst()`

Build a Predicate from an AST node (for OR clauses)

private `appendPredicateFromAst()`

Append conditions from AST node to existing Predicate

private `applyOrderBy()`

Apply ORDER BY clause using table's order() method

private `orderByNeedsExpressionEval()`

Check if ORDER BY contains expressions or aliases that need evaluation

private `executeSelectWithExpressionOrderBy()`

Execute SELECT with expression-based ORDER BY

private `applyWhereToTable()`

Apply a WHERE clause AST to build a query for mutations

private `executeScalarSelect()`

Execute SELECT without FROM (scalar expressions)

private `buildScalarTable()`

Build SingleRowTable from SELECT without FROM

private `expressionToColumnName()`

Convert expression AST to column name string

private `applyJoin()`

Apply a JOIN clause to a table

private `buildJoinPredicate()`

Build a Predicate with bind parameters from a JOIN ON condition

private `appendJoinConditions()`

Append join conditions to a predicate

private `buildQualifiedColumnName()`

Build qualified column name from identifier node

private `resolveColumnForTable()`

Resolve a column name against a table's actual columns

Source

src/Database/VirtualDatabase.php:83-5284

mini\Database\VirtualDatabase class

Documentation

Inheritance

Properties (12)

Methods (149)

`mini\Database\VirtualDatabase` class