@minnowdb/core 0.6.0 → 0.6.1

package/README.md

@@ -8,8 +8,9 @@ npm install @minnowdb/core
 ```
 
 - Direct SQL through `MinnowDatabase.query()` and `execute()`.
-- Joins, CTEs, window functions, grouping sets, upserts, `RETURNING`, triggers, exact decimals,
-  nested JSON/JSONB, stored generated columns, zoneless DATE, arrays, enums, sequences, and savepoints.
+- Joins, CTEs, window functions, grouping sets, nested correlated subqueries, subquery-backed
+  mutations, upserts, `RETURNING`, triggers, exact decimals, nested JSON/JSONB, stored generated
+  columns, zoneless DATE, arrays, enums, sequences, and savepoints.
 - Compressed column storage, secondary indexes, full-text search, and snapshot reads.
 - Atomic writes across tabs through IndexedDB or OPFS, strict durability by default, and explicit
   origin-eviction persistence policy.

package/dist/engine/database.js

@@ -18,7 +18,7 @@ import { applyWindowFunctions, bindPlanParameters, bindStatementParameters, DUAL
 import { copyQueryResult, planMemoKey, queryResultMemoKey, queryResultRetainedBytes, RESULT_MEMO_MAX_BYTES, } from "./query-cache.js";
 import { QueryMemoryBudgetError, QueryMemoryContext, DEFAULT_QUERY_MEMORY_BUDGET_BYTES, } from "./memory.js";
 import { LiveQueryLimitError, LiveQuerySet, MAX_LIVE_QUERY_SETS_PER_DATABASE, } from "./live.js";
-import { chooseJoinOrder, renderPlan } from "./optimizer.js";
+import { chooseJoinOrder, optimizePlan, qualifyCorrelatedReferences, renderPlan, } from "./optimizer.js";
 import { encodeSqlEqualityValue } from "./sql-semantics.js";
 import { externalSqlDomainValue, externalSqlTextValue, isDateDomainValue, isSqlDomainValue, normalizeSqlDomainValue, protectedSqlTextValue, } from "./sql-domains.js";
 import { toCatalog } from "./catalog.js";
@@ -3300,7 +3300,7 @@ export class MinnowDatabase {
         // read has to ask the catalog. It asks by epoch — an O(1) probe the store already serves for
         // result memoization — and only re-reads the view set when the catalog has actually moved.
         // A database with no views therefore pays one probe, not a catalog scan per query.
-        const { views, domains } = await this.#catalogFacts(probe);
+        const { views, domains, columns: catalogColumns } = await this.#catalogFacts(probe);
         let rewritten = plan.usesSequenceCalls === true ? await this.#resolveSequenceCalls(plan) : plan;
         if (views.size > 0 && planReadsViews(plan, (name) => views.has(name))) {
             const bodies = new Map();
@@ -3319,6 +3319,9 @@ export class MinnowDatabase {
         if (domains.size > 0 && planReadsTable(rewritten, (name) => domains.has(name))) {
             rewritten = normalizePlanDomainLiterals(rewritten, domains);
         }
+        const qualified = qualifyCorrelatedReferences(rewritten, catalogColumns);
+        if (qualified !== rewritten)
+            rewritten = optimizePlan(qualified);
         if (!aliased && !natural)
             return rewritten;
         // These two need column *order*, which only the records carry; both are rare enough that
@@ -3431,7 +3434,9 @@ export class MinnowDatabase {
         const views = new Map();
         const childKeys = new Map();
         const domains = new Map();
+        const columns = new Map();
         for (const table of await this.store.listTables()) {
+            columns.set(table.name, table.columns.filter(({ hidden }) => hidden !== true).map(({ name }) => name));
             const tableDomains = new Map(table.columns.flatMap((column) => column.sqlDomain === undefined ? [] : [[column.name, column.sqlDomain]]));
             if (tableDomains.size > 0)
                 domains.set(table.name, tableDomains);
@@ -3445,7 +3450,7 @@ export class MinnowDatabase {
                     existing.push({ table, key });
             }
         }
-        const facts = { views, childKeys, domains };
+        const facts = { views, childKeys, domains, columns };
         this.#catalogCache = { epoch, facts };
         return facts;
     }
@@ -3530,6 +3535,8 @@ export class MinnowDatabase {
     async #queryCompiledFirstColumn(plan, probe) {
         const options = this.#effectiveQueryOptions({ memoize: false });
         plan = await this.#applyCatalogRewrites(plan, probe);
+        if (!this.#canStreamPlanShape(plan, options))
+            return undefined;
         const values = [];
         const streamed = await this.#queryStreamed(plan, options, undefined, probe, {
             batchRows: 2_048,
@@ -7291,7 +7298,7 @@ export class MinnowDatabase {
                 }
             }
         }
-        const plan = {
+        const plan = optimizePlan({
             sql: `(${statement.kind})`,
             base: { table: table.name, alias: table.name },
             joins: [],
@@ -7303,7 +7310,7 @@ export class MinnowDatabase {
             groupBy: [],
             having: [],
             orderBy: [],
-        };
+        });
         if (statement.kind === "delete" && returningColumns === undefined) {
             const internalWriter = options.writer;
             if (internalWriter.queryFirstColumn !== undefined) {

package/dist/engine/optimizer.d.ts

@@ -6,6 +6,13 @@ import { type CompiledQuery } from "./query.js";
  * predicates containing subqueries stay self-contained when they move.
  */
 export declare function optimizePlan(plan: CompiledQuery): CompiledQuery;
+/**
+ * Resolves an unqualified column in a nested block against the nearest enclosing query scope
+ * when that name does not exist in the nested block itself. Compilation has no catalog, so this
+ * SQL name-resolution step runs later for database-backed plans and returns the original plan
+ * unchanged when it finds nothing to qualify.
+ */
+export declare function qualifyCorrelatedReferences(plan: CompiledQuery, tableColumns: ReadonlyMap<string, readonly string[]>): CompiledQuery;
 /**
  * Cost-based build-side selection using prepared or catalog-derived row counts. A single inner
  * equi-join probes from the base into an index over the joined table, so a joined input more than