@minnowdb/core 0.6.9 → 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
@@ -135,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<{
@@ -145,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;
@@ -159,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";
@@ -535,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
@@ -668,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;
 /**