@typed-sql/postgres 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/packages/postgres/src/resolver.js

@@ -1,48 +1,77 @@
-import { defaultPostgresTypePolicy, isKnownPostgresType, mapPostgresType } from "./type-policy.js";
+import { closestName, ParameterCollector, ResolverSchemaIndex, unionTypeLiterals, } from "@typed-sql/core";
+import { defaultPostgresTypePolicy, isKnownPostgresType, mapPostgresType, } from "./type-policy.js";
 const booleanOperators = new Set([
-    "=", "!=", "<>", "<", "<=", ">", ">=", "IS", "IS NOT", "IS DISTINCT FROM",
-    "IS NOT DISTINCT FROM", "LIKE", "NOT LIKE", "ILIKE", "NOT ILIKE", "SIMILAR TO",
-    "NOT SIMILAR", "~", "~*", "!~", "!~*", "AND", "OR", "@>", "<@", "?", "?|", "?&", "&&",
+    "=",
+    "!=",
+    "<>",
+    "<",
+    "<=",
+    ">",
+    ">=",
+    "IS",
+    "IS NOT",
+    "IS DISTINCT FROM",
+    "IS NOT DISTINCT FROM",
+    "LIKE",
+    "NOT LIKE",
+    "ILIKE",
+    "NOT ILIKE",
+    "SIMILAR TO",
+    "NOT SIMILAR",
+    "~",
+    "~*",
+    "!~",
+    "!~*",
+    "AND",
+    "OR",
+    "@>",
+    "<@",
+    "?",
+    "?|",
+    "?&",
+    "&&",
+]);
+const numericTypes = new Set([
+    "smallint",
+    "int2",
+    "integer",
+    "int",
+    "int4",
+    "bigint",
+    "int8",
+    "numeric",
+    "decimal",
+    "real",
+    "float4",
+    "double precision",
+    "float8",
 ]);
-const numericTypes = new Set(["smallint", "int2", "integer", "int", "int4", "bigint", "int8", "numeric", "decimal", "real", "float4", "double precision", "float8"]);
 function sqlName(identifier) {
     return identifier.quoted ? identifier.name : identifier.name.toLowerCase();
 }
 function normalizeDatabaseType(value) {
-    return value.trim().toLowerCase().replace(/\(\d+(?:,\s*\d+)?\)/gu, "").replace(/\s+/gu, " ");
-}
-function distance(a, b) {
-    const rows = Array.from({ length: a.length + 1 }, (_, index) => index);
-    for (let column = 1; column <= b.length; column += 1) {
-        let diagonal = rows[0];
-        rows[0] = column;
-        for (let row = 1; row <= a.length; row += 1) {
-            const above = rows[row];
-            rows[row] = Math.min(rows[row] + 1, rows[row - 1] + 1, diagonal + (a[row - 1] === b[column - 1] ? 0 : 1));
-            diagonal = above;
-        }
-    }
-    return rows[a.length];
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/\(\d+(?:,\s*\d+)?\)/gu, "")
+        .replace(/\s+/gu, " ");
 }
 function suggestion(name, candidates) {
-    const candidate = [...candidates].sort((a, b) => distance(name, a) - distance(name, b))[0];
-    if (candidate === undefined || distance(name, candidate) > Math.max(2, Math.floor(name.length / 2)))
+    const candidate = closestName(name, candidates);
+    if (candidate === undefined)
         return undefined;
     return `Did you mean ${candidate}?`;
 }
-function unionTypes(types) {
-    const distinct = [...new Set(types)];
-    if (distinct.includes("unknown"))
-        return "unknown";
-    return distinct.join(" | ") || "unknown";
-}
 class Resolver {
     #schema;
     #policy;
     #strictExpressions;
     #diagnostics = [];
+    #parameters = new ParameterCollector();
+    #index;
     constructor(schema, options) {
         this.#schema = schema;
+        this.#index = new ResolverSchemaIndex(schema);
         this.#policy = options.typePolicy ?? defaultPostgresTypePolicy;
         this.#strictExpressions = options.strictExpressions ?? true;
     }
@@ -51,15 +80,23 @@ class Resolver {
             this.#diagnostic("TSQ007", `PostgreSQL resolver cannot analyze ${this.#schema.dialect}`, statement.range);
         }
         const result = this.#resolveStatement(statement, undefined, new Map());
-        return { ...result, diagnostics: this.#diagnostics };
+        return {
+            ...result,
+            parameters: this.#parameters.values(),
+            diagnostics: this.#diagnostics,
+        };
     }
     #resolveStatement(statement, outer, inheritedCtes) {
         const ctes = this.#resolveWith(statement.with, outer, inheritedCtes);
         switch (statement.kind) {
-            case "select": return { columns: this.#resolveSelect(statement, outer, ctes), resultKind: "rows" };
-            case "insert": return this.#resolveInsert(statement, outer, ctes);
-            case "update": return this.#resolveUpdate(statement, outer, ctes);
-            case "delete": return this.#resolveDelete(statement, outer, ctes);
+            case "select":
+                return { columns: this.#resolveSelect(statement, outer, ctes), resultKind: "rows" };
+            case "insert":
+                return this.#resolveInsert(statement, outer, ctes);
+            case "update":
+                return this.#resolveUpdate(statement, outer, ctes);
+            case "delete":
+                return this.#resolveDelete(statement, outer, ctes);
         }
     }
     #resolveWith(withClause, outer, inherited) {
@@ -76,7 +113,12 @@ class Resolver {
             if (withClause.recursive) {
                 const placeholderColumns = {};
                 for (const column of query.columns) {
-                    placeholderColumns[sqlName(column)] = { name: sqlName(column), databaseType: "unknown", tsType: "unknown", nullable: true };
+                    placeholderColumns[sqlName(column)] = {
+                        name: sqlName(column),
+                        databaseType: "unknown",
+                        tsType: "unknown",
+                        nullable: true,
+                    };
                 }
                 ctes.set(key, { name: key, columns: placeholderColumns });
             }
@@ -109,11 +151,11 @@ class Resolver {
         for (const join of statement.joins)
             this.#addJoin(join, scope, ctes);
         if (statement.where !== undefined)
-            this.#resolveExpression(statement.where, scope, ctes);
+            this.#resolveExpression(statement.where, scope, ctes, this.#databaseType("boolean", false));
         for (const expression of statement.groupBy)
             this.#resolveExpression(expression, scope, ctes);
         if (statement.having !== undefined)
-            this.#resolveExpression(statement.having, scope, ctes);
+            this.#resolveExpression(statement.having, scope, ctes, this.#databaseType("boolean", false));
         for (const expression of statement.distinctOn)
             this.#resolveExpression(expression, scope, ctes);
         for (const window of statement.windows) {
@@ -125,9 +167,9 @@ class Resolver {
         for (const order of statement.orderBy)
             this.#resolveExpression(order.expression, scope, ctes);
         if (statement.limit !== undefined)
-            this.#resolveExpression(statement.limit, scope, ctes);
+            this.#resolveExpression(statement.limit, scope, ctes, this.#databaseType("integer", false));
         if (statement.offset !== undefined)
-            this.#resolveExpression(statement.offset, scope, ctes);
+            this.#resolveExpression(statement.offset, scope, ctes, this.#databaseType("integer", false));
         return this.#resolveItems(statement.columns, scope, ctes);
     }
     #resolveInsert(statement, outer, ctes) {
@@ -141,8 +183,9 @@ class Resolver {
                 if (row.length !== targetColumns.length) {
                     this.#diagnostic("TSQ214", `INSERT has ${targetColumns.length} target columns but ${row.length} values`, statement.source.range);
                 }
-                for (const value of row)
-                    this.#resolveExpression(value, scope, ctes);
+                row.forEach((value, index) => {
+                    this.#resolveExpression(value, scope, ctes, this.#snapshotType(targetColumns[index]));
+                });
             }
         }
         else if (statement.source.kind === "select") {
@@ -158,15 +201,15 @@ class Resolver {
         const scope = { relations: [], usingColumns: new Map(), ...(outer === undefined ? {} : { outer }) };
         const target = this.#addRelation(statement.table, false, scope, ctes);
         for (const assignment of statement.assignments) {
-            this.#findColumn(target?.table, assignment.column);
-            this.#resolveExpression(assignment.value, scope, ctes);
+            const column = this.#findColumn(target?.table, assignment.column);
+            this.#resolveExpression(assignment.value, scope, ctes, this.#snapshotType(column));
         }
         if (statement.from !== undefined)
             this.#addRelation(statement.from, false, scope, ctes);
         for (const join of statement.joins)
             this.#addJoin(join, scope, ctes);
         if (statement.where !== undefined)
-            this.#resolveExpression(statement.where, scope, ctes);
+            this.#resolveExpression(statement.where, scope, ctes, this.#databaseType("boolean", false));
         const columns = this.#resolveItems(statement.returning, scope, ctes);
         return { columns, resultKind: statement.returning.length === 0 ? "command" : "rows" };
     }
@@ -176,7 +219,7 @@ class Resolver {
         for (const reference of statement.using)
             this.#addRelation(reference, false, scope, ctes);
         if (statement.where !== undefined)
-            this.#resolveExpression(statement.where, scope, ctes);
+            this.#resolveExpression(statement.where, scope, ctes, this.#databaseType("boolean", false));
         const columns = this.#resolveItems(statement.returning, scope, ctes);
         return { columns, resultKind: statement.returning.length === 0 ? "command" : "rows" };
     }
@@ -187,7 +230,7 @@ class Resolver {
                 relation.nullable = true;
         const relation = this.#addRelation(join.table, join.kind === "left" || join.kind === "full", scope, ctes);
         if (join.on !== undefined)
-            this.#resolveExpression(join.on, scope, ctes);
+            this.#resolveExpression(join.on, scope, ctes, this.#databaseType("boolean", false));
         if (join.using !== undefined && relation !== undefined) {
             for (const identifier of join.using) {
                 const name = sqlName(identifier);
@@ -200,9 +243,15 @@ class Resolver {
                 const left = this.#columnType(leftMatches[0], this.#column(leftMatches[0], name, identifier.quoted));
                 const rightType = this.#columnType(relation, right);
                 scope.usingColumns.set(name, {
-                    tsType: unionTypes([left.tsType, rightType.tsType]),
-                    nullable: join.kind === "left" ? left.nullable : join.kind === "right" ? rightType.nullable : left.nullable || rightType.nullable,
-                    ...(left.databaseType === rightType.databaseType && left.databaseType !== undefined ? { databaseType: left.databaseType } : {}),
+                    tsType: unionTypeLiterals([left.tsType, rightType.tsType]),
+                    nullable: join.kind === "left"
+                        ? left.nullable
+                        : join.kind === "right"
+                            ? rightType.nullable
+                            : left.nullable || rightType.nullable,
+                    ...(left.databaseType === rightType.databaseType && left.databaseType !== undefined
+                        ? { databaseType: left.databaseType }
+                        : {}),
                 });
             }
         }
@@ -231,15 +280,7 @@ class Resolver {
             if (requestedSchema === undefined)
                 table = ctes.get(requested);
             if (table === undefined) {
-                const entries = Object.entries(this.#schema.tables).filter(([key, candidate]) => {
-                    const nameMatches = reference.name.quoted
-                        ? key === requested || key.endsWith(`.${requested}`) || candidate.name === requested
-                        : key.toLowerCase() === requested || key.toLowerCase().endsWith(`.${requested}`) || candidate.name.toLowerCase() === requested;
-                    const schemaMatches = requestedSchema === undefined || (reference.schema?.quoted
-                        ? candidate.schema === requestedSchema || key === `${requestedSchema}.${requested}`
-                        : candidate.schema?.toLowerCase() === requestedSchema || key.toLowerCase() === `${requestedSchema}.${requested}`);
-                    return nameMatches && schemaMatches;
-                });
+                const entries = this.#index.tables(requested, requestedSchema, reference.name.quoted || reference.schema?.quoted === true);
                 if (entries.length === 0) {
                     this.#diagnostic("TSQ100", `Unknown table ${reference.name.name}`, reference.name.range, suggestion(requested, [...ctes.keys(), ...Object.keys(this.#schema.tables)]));
                     return undefined;
@@ -248,7 +289,7 @@ class Resolver {
                     this.#diagnostic("TSQ107", `Ambiguous table ${reference.name.name}`, reference.name.range, "Qualify the table with a schema name.");
                     return undefined;
                 }
-                table = entries[0][1];
+                table = entries[0].table;
             }
             alias = reference.alias === undefined ? requested : sqlName(reference.alias);
         }
@@ -278,7 +319,9 @@ class Resolver {
                     ? scope.relations
                     : scope.relations.filter((relation) => relation.alias === sqlName(star.relation));
                 if (relations.length === 0) {
-                    this.#diagnostic("TSQ103", star.relation === undefined ? "SELECT * requires a FROM relation" : `Unknown relation alias ${star.relation.name}`, star.range);
+                    this.#diagnostic("TSQ103", star.relation === undefined
+                        ? "SELECT * requires a FROM relation"
+                        : `Unknown relation alias ${star.relation.name}`, star.range);
                     continue;
                 }
                 if (star.relation === undefined) {
@@ -287,7 +330,8 @@ class Resolver {
                 }
                 for (const relation of relations) {
                     for (const column of Object.values(relation.table.columns)) {
-                        if (star.relation === undefined && (scope.usingColumns.has(column.name) || scope.usingColumns.has(column.name.toLowerCase())))
+                        if (star.relation === undefined &&
+                            (scope.usingColumns.has(column.name) || scope.usingColumns.has(column.name.toLowerCase())))
                             continue;
                         add({ name: column.name, ...this.#columnType(relation, column), range: item.range });
                     }
@@ -317,7 +361,7 @@ class Resolver {
             return "case";
         return undefined;
     }
-    #resolveExpression(expression, scope, ctes) {
+    #resolveExpression(expression, scope, ctes, expected) {
         switch (expression.kind) {
             case "column": {
                 if (expression.relation === undefined && expression.column.name === "DEFAULT")
@@ -330,15 +374,23 @@ class Resolver {
                 if (typeof expression.value === "boolean")
                     return { tsType: "boolean", nullable: false, databaseType: "boolean" };
                 if (typeof expression.value === "number")
-                    return { tsType: "number", nullable: false, databaseType: Number.isInteger(expression.value) ? "integer" : "numeric" };
+                    return {
+                        tsType: "number",
+                        nullable: false,
+                        databaseType: Number.isInteger(expression.value) ? "integer" : "numeric",
+                    };
                 return { tsType: "string", nullable: false, databaseType: "text" };
             }
-            case "parameter": return { tsType: "unknown", nullable: true };
-            case "star": return { tsType: "unknown", nullable: false };
+            case "parameter":
+                return this.#recordParameter(expression.index, expected);
+            case "star":
+                return { tsType: "unknown", nullable: false };
             case "array": {
                 const elements = expression.elements.map((element) => this.#resolveExpression(element, scope, ctes));
-                const elementType = unionTypes(elements.map((element) => element.tsType));
-                const databaseTypes = [...new Set(elements.map((element) => element.databaseType).filter((value) => value !== undefined))];
+                const elementType = unionTypeLiterals(elements.map((element) => element.tsType));
+                const databaseTypes = [
+                    ...new Set(elements.map((element) => element.databaseType).filter((value) => value !== undefined)),
+                ];
                 return {
                     tsType: `readonly (${elementType})[]`,
                     nullable: false,
@@ -347,21 +399,33 @@ class Resolver {
             }
             case "row": {
                 const elements = expression.elements.map((element) => this.#resolveExpression(element, scope, ctes));
-                return { tsType: `readonly [${elements.map((element) => element.tsType + (element.nullable ? " | null" : "")).join(", ")}]`, nullable: false };
+                return {
+                    tsType: `readonly [${elements.map((element) => element.tsType + (element.nullable ? " | null" : "")).join(", ")}]`,
+                    nullable: false,
+                };
             }
             case "cast": {
-                const source = this.#resolveExpression(expression.expression, scope, ctes);
+                const castType = this.#databaseType(expression.databaseType.name, true);
+                const source = this.#resolveExpression(expression.expression, scope, ctes, castType);
                 if (!isKnownPostgresType(expression.databaseType.name, this.#schema)) {
                     this.#diagnostic("TSQ106", `Invalid or unknown PostgreSQL cast type ${expression.databaseType.name}`, expression.databaseType.range);
                 }
-                return { tsType: mapPostgresType(expression.databaseType.name, this.#policy, this.#schema), nullable: source.nullable, databaseType: normalizeDatabaseType(expression.databaseType.name) };
+                return {
+                    tsType: mapPostgresType(expression.databaseType.name, this.#policy, this.#schema),
+                    nullable: source.nullable,
+                    databaseType: normalizeDatabaseType(expression.databaseType.name),
+                };
             }
             case "unary": {
                 const operand = this.#resolveExpression(expression.expression, scope, ctes);
-                return expression.operator === "NOT" ? { tsType: "boolean", nullable: operand.nullable, databaseType: "boolean" } : operand;
+                return expression.operator === "NOT"
+                    ? { tsType: "boolean", nullable: operand.nullable, databaseType: "boolean" }
+                    : operand;
             }
-            case "binary": return this.#resolveBinary(expression, scope, ctes);
-            case "call": return this.#resolveCall(expression, scope, ctes);
+            case "binary":
+                return this.#resolveBinary(expression, scope, ctes);
+            case "call":
+                return this.#resolveCall(expression, scope, ctes);
             case "case": {
                 if (expression.operand !== undefined)
                     this.#resolveExpression(expression.operand, scope, ctes);
@@ -370,9 +434,11 @@ class Resolver {
                 const results = expression.branches.map((branch) => this.#resolveExpression(branch.then, scope, ctes));
                 if (expression.elseExpression !== undefined)
                     results.push(this.#resolveExpression(expression.elseExpression, scope, ctes));
-                const databaseTypes = [...new Set(results.map((result) => result.databaseType).filter((value) => value !== undefined))];
+                const databaseTypes = [
+                    ...new Set(results.map((result) => result.databaseType).filter((value) => value !== undefined)),
+                ];
                 return {
-                    tsType: unionTypes(results.map((result) => result.tsType)),
+                    tsType: unionTypeLiterals(results.map((result) => result.tsType)),
                     nullable: expression.elseExpression === undefined || results.some((result) => result.nullable),
                     ...(databaseTypes.length === 1 ? { databaseType: databaseTypes[0] } : {}),
                 };
@@ -384,7 +450,11 @@ class Resolver {
                     return { tsType: "unknown", nullable: true };
                 }
                 const column = resolved.columns[0];
-                return { tsType: column.tsType, nullable: true, ...(column.databaseType === undefined ? {} : { databaseType: column.databaseType }) };
+                return {
+                    tsType: column.tsType,
+                    nullable: true,
+                    ...(column.databaseType === undefined ? {} : { databaseType: column.databaseType }),
+                };
             }
             case "exists": {
                 this.#resolveStatement(expression.query, scope, ctes);
@@ -394,7 +464,7 @@ class Resolver {
                 const subject = this.#resolveExpression(expression.expression, scope, ctes);
                 let nullable = subject.nullable;
                 if (Array.isArray(expression.values)) {
-                    const values = expression.values.map((value) => this.#resolveExpression(value, scope, ctes));
+                    const values = expression.values.map((value) => this.#resolveExpression(value, scope, ctes, subject));
                     nullable ||= values.some((value) => value.nullable);
                 }
                 else {
@@ -407,18 +477,34 @@ class Resolver {
             }
             case "between": {
                 const subject = this.#resolveExpression(expression.expression, scope, ctes);
-                const lower = this.#resolveExpression(expression.lower, scope, ctes);
-                const upper = this.#resolveExpression(expression.upper, scope, ctes);
-                return { tsType: "boolean", nullable: subject.nullable || lower.nullable || upper.nullable, databaseType: "boolean" };
+                const lower = this.#resolveExpression(expression.lower, scope, ctes, subject);
+                const upper = this.#resolveExpression(expression.upper, scope, ctes, subject);
+                return {
+                    tsType: "boolean",
+                    nullable: subject.nullable || lower.nullable || upper.nullable,
+                    databaseType: "boolean",
+                };
             }
         }
     }
     #resolveBinary(expression, scope, ctes) {
-        const left = this.#resolveExpression(expression.left, scope, ctes);
-        const right = this.#resolveExpression(expression.right, scope, ctes);
+        let left;
+        let right;
+        if (expression.left.kind === "parameter" && expression.right.kind !== "parameter") {
+            right = this.#resolveExpression(expression.right, scope, ctes);
+            left = this.#resolveExpression(expression.left, scope, ctes, right);
+        }
+        else {
+            left = this.#resolveExpression(expression.left, scope, ctes);
+            right = this.#resolveExpression(expression.right, scope, ctes, expression.right.kind === "parameter" ? left : undefined);
+        }
         if (booleanOperators.has(expression.operator)) {
             const neverNull = expression.operator.startsWith("IS");
-            return { tsType: "boolean", nullable: neverNull ? false : left.nullable || right.nullable, databaseType: "boolean" };
+            return {
+                tsType: "boolean",
+                nullable: neverNull ? false : left.nullable || right.nullable,
+                databaseType: "boolean",
+            };
         }
         if (["->", "#>"].includes(expression.operator))
             return { tsType: this.#policy.json, nullable: true, databaseType: "jsonb" };
@@ -427,15 +513,28 @@ class Resolver {
         if (expression.operator === "||") {
             if (left.tsType.startsWith("readonly (") && right.tsType.startsWith("readonly (")) {
                 const databaseType = left.databaseType ?? right.databaseType;
-                return { tsType: unionTypes([left.tsType, right.tsType]), nullable: left.nullable || right.nullable, ...(databaseType === undefined ? {} : { databaseType }) };
+                return {
+                    tsType: unionTypeLiterals([left.tsType, right.tsType]),
+                    nullable: left.nullable || right.nullable,
+                    ...(databaseType === undefined ? {} : { databaseType }),
+                };
             }
             return { tsType: "string", nullable: left.nullable || right.nullable, databaseType: "text" };
         }
         const leftDatabase = left.databaseType === undefined ? undefined : normalizeDatabaseType(left.databaseType);
         const rightDatabase = right.databaseType === undefined ? undefined : normalizeDatabaseType(right.databaseType);
-        if (leftDatabase !== undefined && rightDatabase !== undefined && numericTypes.has(leftDatabase) && numericTypes.has(rightDatabase)) {
-            const databaseType = [leftDatabase, rightDatabase].some((type) => type === "numeric" || type === "decimal") ? "numeric" : "double precision";
-            return { tsType: databaseType === "numeric" ? this.#policy.numeric : "number", nullable: left.nullable || right.nullable, databaseType };
+        if (leftDatabase !== undefined &&
+            rightDatabase !== undefined &&
+            numericTypes.has(leftDatabase) &&
+            numericTypes.has(rightDatabase)) {
+            const databaseType = [leftDatabase, rightDatabase].some((type) => type === "numeric" || type === "decimal")
+                ? "numeric"
+                : "double precision";
+            return {
+                tsType: databaseType === "numeric" ? this.#policy.numeric : "number",
+                nullable: left.nullable || right.nullable,
+                databaseType,
+            };
         }
         if (left.tsType === "unknown" || right.tsType === "unknown")
             return { tsType: "unknown", nullable: left.nullable || right.nullable };
@@ -487,15 +586,11 @@ class Resolver {
         return scope.relations.find((candidate) => candidate.alias === alias);
     }
     #column(relation, name, quoted = false) {
-        return Object.entries(relation.table.columns).find(([key, column]) => quoted
-            ? key === name || column.name === name
-            : key.toLowerCase() === name || column.name.toLowerCase() === name)?.[1];
+        return this.#index.column(relation.table, name, quoted);
     }
     #findColumn(table, identifier) {
         const name = sqlName(identifier);
-        const column = table === undefined ? undefined : Object.entries(table.columns).find(([key, candidate]) => identifier.quoted
-            ? key === name || candidate.name === name
-            : key.toLowerCase() === name || candidate.name.toLowerCase() === name)?.[1];
+        const column = table === undefined ? undefined : this.#index.column(table, name, identifier.quoted);
         if (column === undefined)
             this.#diagnostic("TSQ101", `Unknown column ${name}`, identifier.range, suggestion(name, Object.keys(table?.columns ?? {})));
         return column;
@@ -522,17 +617,28 @@ class Resolver {
                 return argument?.kind !== "literal" || argument.value !== null;
             });
             return {
-                tsType: unionTypes(known.map((result) => result.tsType)),
+                tsType: unionTypeLiterals(known.map((result) => result.tsType)),
                 nullable: resolved.every((result) => result.nullable),
-                ...(known.length > 0 && known.every((result) => result.databaseType === known[0]?.databaseType) && known[0]?.databaseType !== undefined ? { databaseType: known[0].databaseType } : {}),
+                ...(known.length > 0 &&
+                    known.every((result) => result.databaseType === known[0]?.databaseType) &&
+                    known[0]?.databaseType !== undefined
+                    ? { databaseType: known[0].databaseType }
+                    : {}),
             };
         }
         if (name === "NULLIF")
             return { ...(resolved[0] ?? { tsType: "unknown" }), nullable: true };
         if (["MIN", "MAX", "GREATEST", "LEAST"].includes(name))
-            return { ...(resolved[0] ?? { tsType: "unknown", nullable: true }), nullable: name === "MIN" || name === "MAX" ? true : resolved.some((result) => result.nullable) };
+            return {
+                ...(resolved[0] ?? { tsType: "unknown", nullable: true }),
+                nullable: name === "MIN" || name === "MAX" ? true : resolved.some((result) => result.nullable),
+            };
         if (name === "SUM" || name === "AVG")
-            return { tsType: resolved[0]?.tsType ?? this.#policy.numeric, nullable: true, databaseType: resolved[0]?.databaseType ?? "numeric" };
+            return {
+                tsType: resolved[0]?.tsType ?? this.#policy.numeric,
+                nullable: true,
+                databaseType: resolved[0]?.databaseType ?? "numeric",
+            };
         if (["BOOL_AND", "BOOL_OR", "EVERY"].includes(name))
             return { tsType: "boolean", nullable: true, databaseType: "boolean" };
         if (name === "STRING_AGG")
@@ -541,20 +647,28 @@ class Resolver {
             return { tsType: this.#policy.json, nullable: true, databaseType: name.startsWith("JSONB") ? "jsonb" : "json" };
         if (name === "ARRAY_AGG") {
             const item = resolved[0] ?? { tsType: "unknown", nullable: true };
-            return { tsType: `readonly (${item.tsType}${item.nullable ? " | null" : ""})[]`, nullable: true, ...(item.databaseType === undefined ? {} : { databaseType: `${item.databaseType}[]` }) };
+            return {
+                tsType: `readonly (${item.tsType}${item.nullable ? " | null" : ""})[]`,
+                nullable: true,
+                ...(item.databaseType === undefined ? {} : { databaseType: `${item.databaseType}[]` }),
+            };
         }
         const functionName = sqlName(expression.name);
         const schemaName = expression.schema === undefined ? undefined : sqlName(expression.schema);
-        const candidates = Object.values(this.#schema.functions ?? {}).filter((candidate) => candidate.name.toLowerCase() === functionName
-            && candidate.argumentTypes.length === expression.arguments.length
-            && (schemaName === undefined || candidate.schema?.toLowerCase() === schemaName));
+        const candidates = this.#index.functions(functionName, expression.arguments.length, schemaName);
         const exact = candidates.filter((candidate) => candidate.argumentTypes.every((type, index) => {
             const actual = resolved[index]?.databaseType;
             return actual === undefined || this.#typesCompatible(type, actual);
         }));
         const selected = exact.length === 1 ? exact[0] : candidates.length === 1 ? candidates[0] : undefined;
-        if (selected !== undefined)
+        if (selected !== undefined) {
+            expression.arguments.forEach((argument, index) => {
+                if (argument.kind === "parameter") {
+                    this.#resolveExpression(argument, scope, ctes, this.#databaseType(selected.argumentTypes[index], true));
+                }
+            });
             return this.#functionType(selected);
+        }
         if (exact.length > 1 || candidates.length > 1) {
             this.#diagnostic("TSQ204", `Ambiguous overloaded function ${expression.name.name}`, expression.range, "Cast arguments to select a specific overload.");
             return { tsType: "unknown", nullable: true };
@@ -578,8 +692,29 @@ class Resolver {
             ...(value.databaseReturnType === undefined ? {} : { databaseType: value.databaseReturnType }),
         };
     }
+    #snapshotType(column) {
+        if (column === undefined)
+            return undefined;
+        return { tsType: column.tsType, nullable: column.nullable, databaseType: column.databaseType };
+    }
+    #databaseType(databaseType, nullable) {
+        return {
+            tsType: mapPostgresType(databaseType, this.#policy, this.#schema),
+            nullable,
+            databaseType: normalizeDatabaseType(databaseType),
+        };
+    }
+    #recordParameter(index, expected) {
+        return this.#parameters.record(index, expected);
+    }
     #diagnostic(code, message, range, suggestionText, severity = "error") {
-        this.#diagnostics.push({ code, message, range, severity, ...(suggestionText === undefined ? {} : { suggestion: suggestionText }) });
+        this.#diagnostics.push({
+            code,
+            message,
+            range,
+            severity,
+            ...(suggestionText === undefined ? {} : { suggestion: suggestionText }),
+        });
     }
 }
 export function resolveStatement(statement, schema, options = {}) {
@@ -588,8 +723,5 @@ export function resolveStatement(statement, schema, options = {}) {
 export function resolveSelect(statement, schema, options = {}) {
     return resolveStatement(statement, schema, options);
 }
-export function rowTypeLiteral(columns) {
-    const properties = columns.map((column) => `${JSON.stringify(column.name)}: ${column.tsType}${column.nullable ? " | null" : ""};`);
-    return `{ ${properties.join(" ")} }`;
-}
+export { rowTypeLiteral } from "@typed-sql/core";
 //# sourceMappingURL=resolver.js.map