@minnowdb/core 0.6.8 → 0.7.0

package/dist/engine/query.d.ts

@@ -40,6 +40,14 @@ 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 type ScalarFunctionEvaluator = (values: readonly unknown[]) => unknown;
+/**
+ * The evaluator for one function name, resolved once. A call site that keeps the evaluator
+ * skips the name dispatch on every row; the registry functions and the hottest built-ins get
+ * a closure of their own, everything else a closure over the general dispatch.
+ */
+export declare function scalarFunctionEvaluator(name: Exclude<ScalarFunctionName, "COALESCE">): ScalarFunctionEvaluator;
+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. */
@@ -56,6 +64,14 @@ interface CompileQueryOptions {
     /** Set false to skip deterministic plan rewrites, for example to snapshot the raw plan. */
     readonly optimize?: boolean;
 }
+/** One RETURNING item beyond a plain column: its statement text, output name, and the column it names when it is one. */
+export interface ReturningItem {
+    sql: string;
+    alias: string;
+    expression: Expression;
+    /** The target column the item names, when it is a bare column reference. */
+    column?: string;
+}
 export declare function compileQuery(sql: string, options?: CompileQueryOptions): CompiledQuery;
 /**
  * One WHEN clause of a MERGE (F312). Branches are tried in order for each source row, and the
@@ -105,10 +121,14 @@ export interface UniqueConstraintDefinition {
 interface DefaultInsertValue {
     readonly default: true;
 }
-export type InsertValue = QueryValue | DefaultInsertValue | {
+interface DeferredInsertExpression {
+    readonly expression: Expression;
+}
+export type InsertValue = QueryValue | DefaultInsertValue | DeferredInsertExpression | {
     parameter: number;
 };
 export declare function isDefaultInsertValue(value: InsertValue): value is DefaultInsertValue;
+export declare function isDeferredInsertExpression(value: InsertValue): value is DeferredInsertExpression;
 export type CompiledStatement = {
     kind: "select";
     sql: string;
@@ -131,6 +151,11 @@ export type CompiledStatement = {
         column: string;
         /** The full PostgreSQL conflict target; `column` remains the scalar fast-path name. */
         columns?: string[];
+        /**
+         * `ON CONFLICT DO NOTHING` with no target: the statement names no columns, and the
+         * table's unique key is resolved at execution, where the catalog is known.
+         */
+        anyTarget?: true;
         action: "nothing" | "replace" | "update";
         /** Expressions evaluated against the stored target row and the proposed EXCLUDED row. */
         assignments?: Array<{
@@ -141,10 +166,14 @@ export type CompiledStatement = {
         where?: Expression;
     };
     returning?: string[] | "*";
+    /** RETURNING items that are not plain columns, evaluated over the affected rows. */
+    returningItems?: ReturningItem[];
     parameterCount?: number;
 } | {
     kind: "update";
     table: string;
+    /** `UPDATE t AS u`: the name the assignments, predicates, and RETURNING may qualify by. */
+    alias?: string;
     assignments: Array<{
         column: string;
         expression: Expression;
@@ -155,16 +184,21 @@ export type CompiledStatement = {
         right: Expression;
     }>;
     returning?: string[] | "*";
+    /** RETURNING items that are not plain columns, evaluated over the affected rows. */
+    returningItems?: ReturningItem[];
     parameterCount?: number;
 } | {
     kind: "delete";
     table: string;
+    alias?: string;
     predicates: Array<{
         left: Expression;
         operator: PredicateOperator;
         right: Expression;
     }>;
     returning?: string[] | "*";
+    /** RETURNING items that are not plain columns, evaluated over the affected rows. */
+    returningItems?: ReturningItem[];
     parameterCount?: number;
 } | {
     kind: "create-table";
@@ -531,6 +565,8 @@ export declare function orderOutputName(expression: Expression, select: readonly
 interface ListMembership {
     set: ReadonlySet<unknown>;
     hasNull: boolean;
+    /** Whether any member is text, which a typed left value may read in its own type. */
+    hasText: boolean;
 }
 /**
  * IN lists produced by subquery materialization can hold many thousands of literals, and
@@ -626,6 +662,15 @@ 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;
+/** Whether any block still needs source schemas before its SELECT shape can be lowered. */
+export declare function planHasPendingSelectShapes(plan: CompiledQuery): boolean;
+/**
+ * Expands schema-dependent SELECT wildcards, then sends the now-concrete block through the same
+ * lowering used by ordinary named select lists. This is the single boundary at which wildcard
+ * width becomes plan shape: DISTINCT, windows, ORDER BY expressions/ordinals, set operations,
+ * CTE/derived column lists, grouping sets, and FULL JOIN therefore cannot disagree about it.
+ */
+export declare function bindPendingSelectShapes(plan: CompiledQuery, columnsOf: (tableName: string) => readonly string[] | undefined): CompiledQuery;
 /** Whether any block of the plan still carries an unresolved NATURAL join marker. */
 export declare function planHasNaturalJoins(plan: CompiledQuery): boolean;
 /**
@@ -655,6 +700,13 @@ 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;
+/**
+ * Reads datetime text the way the TIMESTAMP literal does — a zoneless `2026-01-02 03:04:05` is
+ * UTC, never the host's zone — and falls back to the JavaScript parser for other spellings.
+ * `new Date("2026-01-02 03:04:05")` alone would read the same text in local time, so a CAST
+ * would answer differently on two machines.
+ */
+export declare function datetimeText(text: string): Date;
 /** The parser's OFFSET range contract, shared with the typed builder. */
 export declare function validateOffset(offset: number): number;
 /**