@minnowdb/core 0.6.5 → 0.6.7

package/dist/engine/query.d.ts

@@ -31,12 +31,6 @@ export interface QueryExecutionOptions {
 export declare const scalarFunctionNames: ReadonlySet<string>;
 /** Functions whose answer can change without any catalog or input-row change. */
 export declare const volatileScalarFunctionNames: ReadonlySet<string>;
-/**
- * The niladic datetime functions (F051-06/07/08). Their value is the statement's own clock
- * reading, so they are resolved once per execution rather than evaluated per row: every row of
- * one statement sees one instant, both executors agree, and constant folding leaves them alone.
- */
-export declare const statementDatetimeNames: ReadonlySet<string>;
 export declare function isScalarFunctionName(name: AggregateName | ScalarFunctionName): name is ScalarFunctionName;
 /**
  * Evaluates one scalar function over already-evaluated argument values. Every executor calls
@@ -46,23 +40,6 @@ export declare function isScalarFunctionName(name: AggregateName | ScalarFunctio
  * SUBSTR count characters, not UTF-16 units, matching SQLite and PostgreSQL.
  */
 export declare function scalarFunctionValue(name: Exclude<ScalarFunctionName, "COALESCE">, values: readonly unknown[]): unknown;
-export declare const dateTruncUnits: ReadonlySet<string>;
-/**
- * `INTERVAL '1 month'`, `INTERVAL '2 years 3 days'`. Months are kept apart from milliseconds
- * rather than converted, because a month is not a fixed number of them: adding one to January 31
- * has to land on the end of February, which only calendar arithmetic can do.
- */
-export declare function intervalLiteral(text: string): {
-    months: number;
-    milliseconds: number;
-};
-/**
- * A datetime shifted by a calendar interval: whole months first, then milliseconds. A day that
- * does not exist in the target month clamps to that month's last day, which is what both SQLite
- * and PostgreSQL do with 31 January plus a month.
- */
-export declare function dateAddValue(value: unknown, months: unknown, milliseconds: unknown): Date | string | null;
-export declare function dateTruncValue(unit: unknown, value: unknown): Date | null;
 /** The output column type of one window: rankings and most aggregates count, MIN/MAX carry. */
 export declare function windowOutputType(window: WindowSpec, innerSchema: readonly SqlColumnSchema[]): SqlColumnType;
 /** Logical domain carried or produced by a window result, when its physical type is not enough. */
@@ -75,7 +52,7 @@ export declare function windowOutputDomain(window: WindowSpec, innerSchema: read
 export declare const DUAL_TABLE = "(dual)";
 /** The dual source's single row, shared by every resolution path. */
 export declare function dualTableRows(): DatabaseRow[];
-export interface CompileQueryOptions {
+interface CompileQueryOptions {
     /** Set false to skip deterministic plan rewrites, for example to snapshot the raw plan. */
     readonly optimize?: boolean;
 }
@@ -84,7 +61,7 @@ export declare function compileQuery(sql: string, options?: CompileQueryOptions)
  * One WHEN clause of a MERGE (F312). Branches are tried in order for each source row, and the
  * first whose match state and optional condition hold decides what happens to that row.
  */
-export type MergeBranch = {
+type MergeBranch = {
     when: "matched";
     condition?: Expression;
     action: {
@@ -125,7 +102,7 @@ export interface UniqueConstraintDefinition {
     columns: string[];
 }
 /** An INSERT value: a constant, SQL DEFAULT, or an unbound placeholder. */
-export interface DefaultInsertValue {
+interface DefaultInsertValue {
     readonly default: true;
 }
 export type InsertValue = QueryValue | DefaultInsertValue | {
@@ -344,7 +321,7 @@ export type CompiledStatement = {
  * row condition over this table's columns, with no aggregate, window, subquery, or parameter.
  */
 export declare function compileCheckExpression(sql: string, name: string): Expression;
-export interface DefaultExpressionTarget {
+interface DefaultExpressionTarget {
     readonly name: string;
     readonly type: SqlColumnType;
     readonly sqlDomain?: SqlDomain;
@@ -368,7 +345,7 @@ export declare function compileStatement(sql: string): CompiledStatement;
 export declare function evaluateJoinedRowExpression(expression: Expression, rows: Readonly<Record<string, DatabaseRow | undefined>>): QueryValue;
 /** Evaluates an expression against one row, for UPDATE SET assignment computation. */
 export declare function evaluateRowExpression(expression: Expression, alias: string, row: DatabaseRow): QueryValue;
-export interface SubqueryResolutionStep {
+interface SubqueryResolutionStep {
     /** The uncorrelated block to execute; earlier steps have already substituted inside it. */
     readonly block: CompiledQuery;
     /** Replaces the subquery node with the executed result as literals. */
@@ -386,9 +363,6 @@ export declare function subqueryResolutionSteps(plan: CompiledQuery): {
     steps: SubqueryResolutionStep[];
 };
 export declare function blockHasSubqueries(plan: CompiledQuery): boolean;
-/** True when any `?`/`$n` placeholder remains anywhere in the expression tree. */
-export declare function containsParameter(expression: Expression): boolean;
-export declare function blockHasParameters(block: CompiledQuery): boolean;
 /**
  * A deep copy of a compiled plan, statement, or expression tree. Plans are plain data — objects,
  * arrays, primitives, and Date literals — so a direct recursive copy does what structuredClone
@@ -486,7 +460,7 @@ export declare function mapBlockExpressions(block: CompiledQuery, map: (expressi
  */
 export declare function resolveStatementDatetimes(plan: CompiledQuery, now?: Date): CompiledQuery;
 /** One top-level full-text MATCH conjunct of a plan, with its resolved column expressions. */
-export interface FtsMatchConjunct {
+interface FtsMatchConjunct {
     columns: Expression[];
     query: string;
 }
@@ -520,6 +494,17 @@ export declare function planContainsFts(plan: CompiledQuery, op?: "match" | "bm2
  * later migrations.
  */
 export declare function expandFtsColumns(plan: CompiledQuery, searchableColumnsFor: (tableName: string) => readonly string[] | undefined): CompiledQuery;
+/**
+ * Annotates every `AVG(column)` in this block's expression positions with the argument column's
+ * declared NUMERIC scale, resolved against the given schemas. PostgreSQL floors an AVG's
+ * internal division scale at the summed values' display scale; the canonical NUMERIC encoding
+ * strips trailing fractional zeros, so without the annotation the divide cannot know the digits
+ * a declared scale above its own selection would render, and the display padding would fabricate
+ * zeros where PostgreSQL computes real digits. Runs where the catalog is known, per block —
+ * nested blocks execute through their own schema-aware entry. Copy-on-write: plans without an
+ * AVG pass through untouched, and the input is often the compile cache's own object.
+ */
+export declare function annotateAvgArgumentScales(plan: CompiledQuery, schemas: ReadonlyMap<string, readonly SqlColumnSchema[]>): CompiledQuery;
 /**
  * Appends window-function columns to an executed inner-block result. Rows sort stably by the
  * hidden partition and ordering aliases with the same comparison semantics as ORDER BY;
@@ -532,7 +517,7 @@ export declare function applyWindowFunctions(result: QueryResult, windows: reado
 /** Correctness reference retained while the vector executor matures. */
 export declare function executeRowQuery(plan: CompiledQuery, tables: ReadonlyMap<string, DatabaseRow[]>): QueryResult;
 /** One ORDER BY resolution source: an alias and the columns a wildcard select exposes from it. */
-export interface OrderSourceShape {
+interface OrderSourceShape {
     readonly alias: string;
     readonly columns: readonly string[];
 }
@@ -543,7 +528,7 @@ export interface OrderSourceShape {
  * repeated rows.
  */
 export declare function orderOutputName(expression: Expression, select: readonly SelectItem[], sources: readonly OrderSourceShape[]): string;
-export interface ListMembership {
+interface ListMembership {
     set: ReadonlySet<unknown>;
     hasNull: boolean;
 }
@@ -604,7 +589,7 @@ export declare function nullOrder(left: unknown, right: unknown, nulls: "first"
 export declare function copyQueryResultExternalization(source: QueryResult, copy: QueryResult): QueryResult;
 /** Removes internal domain tags only after every comparison, group, join, and sort is complete. */
 export declare function externalizeQueryResult(result: QueryResult): QueryResult;
-export interface SelectBlockParts {
+interface SelectBlockParts {
     sql: string;
     base: TableSource;
     joins: JoinPlan[];
@@ -624,13 +609,6 @@ export interface SelectBlockParts {
     groupingSets?: Expression[][];
 }
 export declare function assembleSelectBlock(parts: SelectBlockParts, nextSequence: () => number): CompiledQuery;
-/**
- * Expands a pending SELECT DISTINCT * against known input columns: the select list becomes
- * every wildcard output (alias-qualified when more than one source contributes), and GROUP BY
- * over those same columns provides the deduplication through the grouped executor. Runs
- * exactly once per execution entry, like MATCH(*) expansion.
- */
-export declare function expandDistinctWildcard(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 /**
  * Turns every source carrying a column alias list into a derived projection that renames the
  * table's columns positionally (E051-09). The table's own column order is only known here, so
@@ -648,15 +626,6 @@ export declare function planReadsViews(plan: CompiledQuery, isView: (name: strin
  */
 export declare function expandViewSources(plan: CompiledQuery, viewFor: (tableName: string) => CompiledQuery | undefined, maxDepth?: number): CompiledQuery;
 export declare function planHasSourceColumnAliases(plan: CompiledQuery): boolean;
-/**
- * FETCH FIRST n ROWS WITH TIES (F866). The plan runs without its limit — a limit pushed into a
- * scan cannot know whether the next row ties — and the ordered result is trimmed here: rows up
- * to the limit, plus every following row equal to the last one on all ORDER BY columns.
- */
-export declare function withTiesPlan(plan: CompiledQuery): {
-    plan: CompiledQuery;
-    trim: (result: QueryResult) => QueryResult;
-};
 /** Whether any block of the plan still carries an unresolved NATURAL join marker. */
 export declare function planHasNaturalJoins(plan: CompiledQuery): boolean;
 /**
@@ -666,13 +635,6 @@ export declare function planHasNaturalJoins(plan: CompiledQuery): boolean;
  */
 export declare function expandNaturalJoins(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 export declare function expandSourceColumnAliases(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
-/**
- * Expands `alias.*` select items into that source's columns (E051-07), at every nesting depth.
- * Output names follow the same rule as a bare `*`: the column's own name when the block reads
- * one source, and `alias.column` when it reads several, so two sources cannot collide.
- * Runs once per execution entry, like MATCH(*) and DISTINCT * expansion.
- */
-export declare function expandQualifiedWildcards(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 /** Wraps compound members into the set-operation source the executor folds left to right. */
 export declare function compoundSelectBlock(sql: string, blocks: CompiledQuery[], ops: SetOperator[], tail: SelectTail, nextSequence: () => number): CompiledQuery;
 /**
@@ -693,7 +655,6 @@ export declare function projectResultColumns(result: QueryResult, aliases: reado
 export declare function derivedTableSource(derived: CompiledQuery, alias: string, nextSequence: () => number): TableSource;
 /** The parser's LIMIT range contract, shared with the typed builder. */
 export declare function validateLimit(limit: number): number;
-export declare function timestampLiteral(text: string): Date;
 /** The parser's OFFSET range contract, shared with the typed builder. */
 export declare function validateOffset(offset: number): number;
 /**