@typed-sql/postgres 2.0.0 → 2.1.0

package/dist/packages/postgres/src/type-resolution.js

@@ -0,0 +1,906 @@
+import { upgradeSchemaSnapshotV1, } from "@typed-sql/schema";
+import { postgresCatalogCanCast, postgresCatalogOperatorRule, postgresCatalogType, postgresCoreCatalogForSchema, } from "./catalog/index.js";
+import { postgresExtensionCasts, postgresExtensionOperators } from "./extensions.js";
+const comparisonOperators = new Set([
+    "<",
+    "<=",
+    "=",
+    ">",
+    ">=",
+    "!=",
+    "<>",
+    "IS DISTINCT FROM",
+    "IS NOT DISTINCT FROM",
+]);
+const patternOperators = new Set([
+    "LIKE",
+    "NOT LIKE",
+    "ILIKE",
+    "NOT ILIKE",
+    "SIMILAR TO",
+    "NOT SIMILAR",
+    "~",
+    "~*",
+    "!~",
+    "!~*",
+]);
+const simplePolymorphicTypes = new Set([
+    "anyelement",
+    "anyarray",
+    "anynonarray",
+    "anyenum",
+    "anyrange",
+    "anymultirange",
+]);
+const compatiblePolymorphicTypes = new Set([
+    "anycompatible",
+    "anycompatiblearray",
+    "anycompatiblenonarray",
+    "anycompatiblerange",
+    "anycompatiblemultirange",
+]);
+const numericOperatorTypes = new Set(["smallint", "integer", "bigint", "numeric", "real", "double precision"]);
+// Operator candidate construction expands PostgreSQL type categories and applies schema-owned
+// extension casts. A snapshot is immutable analysis evidence, so retain the expansion alongside
+// the other snapshot-indexed resolver caches instead of rebuilding it for every expression.
+const operatorCandidatesBySchema = new WeakMap();
+const defaultOperatorCandidates = new Map();
+const upgradedSchemas = new WeakMap();
+const operatorResolutionsBySchema = new WeakMap();
+const defaultOperatorResolutions = new Map();
+function normalize(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/\(\d+(?:,\s*\d+)?\)/gu, "")
+        .replace(/\s+/gu, " ");
+}
+function schemaTypes(schema) {
+    if (schema === undefined)
+        return [];
+    if (schema.formatVersion === 2)
+        return Object.values(schema.types);
+    const cached = upgradedSchemas.get(schema);
+    if (cached !== undefined)
+        return Object.values(cached.types);
+    const upgraded = upgradeSchemaSnapshotV1(schema);
+    upgradedSchemas.set(schema, upgraded);
+    return Object.values(upgraded.types);
+}
+function typeEvidence(databaseType, schema) {
+    const normalized = normalize(databaseType);
+    const types = schemaTypes(schema);
+    const exact = types.find((type) => normalize(type.databaseType) === normalized ||
+        normalize(type.identity) === normalized ||
+        normalize(`${type.schema === undefined ? "" : `${type.schema}.`}${type.name}`) === normalized);
+    if (exact !== undefined)
+        return exact;
+    const unqualified = types.filter((type) => normalize(type.name) === normalized);
+    return unqualified.length === 1 ? unqualified[0] : undefined;
+}
+/** Canonical PostgreSQL type identity for overload and coercion decisions. */
+export function postgresCanonicalType(databaseType, schema) {
+    const normalized = normalize(databaseType);
+    if (normalized.endsWith("[]")) {
+        return `${postgresCanonicalType(normalized.slice(0, -2), schema)}[]`;
+    }
+    return postgresCatalogType(normalized, schema)?.name ?? typeEvidence(normalized, schema)?.databaseType ?? normalized;
+}
+function baseType(databaseType, schema) {
+    const canonical = postgresCanonicalType(databaseType, schema);
+    const evidence = typeEvidence(canonical, schema);
+    if (evidence?.kind !== "domain")
+        return canonical;
+    const base = schemaTypes(schema).find((type) => type.identity === evidence.baseTypeIdentity);
+    return postgresCanonicalType(base?.databaseType ?? evidence.baseTypeIdentity, schema);
+}
+function category(databaseType, schema) {
+    const canonical = baseType(databaseType, schema);
+    if (canonical.endsWith("[]"))
+        return "array";
+    const catalogType = postgresCatalogType(canonical, schema);
+    if (catalogType !== undefined)
+        return catalogType.category;
+    const evidence = typeEvidence(canonical, schema);
+    if (evidence?.kind === "enum")
+        return "enum";
+    if (evidence?.kind === "composite")
+        return "composite";
+    if (evidence?.kind === "range" || evidence?.kind === "multirange")
+        return "range";
+    return evidence === undefined ? undefined : "user";
+}
+/** PostgreSQL type category after aliases and domains are resolved. */
+export function postgresTypeCategory(databaseType, schema) {
+    return category(databaseType, schema);
+}
+function isPreferred(databaseType, schema) {
+    return postgresCatalogType(baseType(databaseType, schema), schema)?.preferred ?? false;
+}
+function elementType(databaseType, schema) {
+    const canonical = postgresCanonicalType(databaseType, schema);
+    if (canonical.endsWith("[]"))
+        return canonical.slice(0, -2);
+    const evidence = typeEvidence(canonical, schema);
+    if (evidence?.kind !== "collection")
+        return undefined;
+    const element = schemaTypes(schema).find((type) => type.identity === evidence.elementTypeIdentity);
+    return element === undefined ? undefined : postgresCanonicalType(element.databaseType, schema);
+}
+/** Returns the element identity for a PostgreSQL array or snapshot collection type. */
+export function postgresElementType(databaseType, schema) {
+    return elementType(databaseType, schema);
+}
+function rangeSubtype(databaseType, schema) {
+    const evidence = typeEvidence(databaseType, schema);
+    if (evidence?.kind !== "range" && evidence?.kind !== "multirange")
+        return undefined;
+    const subtype = schemaTypes(schema).find((type) => type.identity === evidence.subtypeIdentity);
+    return subtype === undefined ? undefined : postgresCanonicalType(subtype.databaseType, schema);
+}
+/** PostgreSQL common-type selection used by compatible polymorphic inputs. */
+export function postgresCommonType(databaseTypes, schema) {
+    const known = databaseTypes
+        .filter((value) => value !== undefined)
+        .map((value) => baseType(value, schema));
+    if (known.length === 0)
+        return "text";
+    if (known.every((value) => value === known[0]))
+        return known[0];
+    const firstCategory = category(known[0], schema);
+    if (firstCategory === undefined || known.some((value) => category(value, schema) !== firstCategory))
+        return undefined;
+    let candidate = known[0];
+    for (const value of known.slice(1)) {
+        if (candidate === value)
+            continue;
+        const candidateToValue = postgresCanCoerce(candidate, value, "implicit", schema);
+        const valueToCandidate = postgresCanCoerce(value, candidate, "implicit", schema);
+        if (!candidateToValue && !valueToCandidate)
+            return undefined;
+        if (candidateToValue && !valueToCandidate)
+            candidate = value;
+        if (isPreferred(candidate, schema))
+            break;
+    }
+    return known.every((value) => postgresCanCoerce(value, candidate, "implicit", schema)) ? candidate : undefined;
+}
+export function postgresCanCoerce(source, target, context, schema) {
+    const sourceType = baseType(source, schema);
+    const targetType = baseType(target, schema);
+    if (sourceType.endsWith("[]") && targetType.endsWith("[]")) {
+        return postgresCanCoerce(sourceType.slice(0, -2), targetType.slice(0, -2), context, schema);
+    }
+    const sourceCategory = category(sourceType, schema);
+    const targetCategory = category(targetType, schema);
+    if (sourceCategory !== undefined &&
+        targetCategory !== undefined &&
+        ((context !== "implicit" && targetCategory === "string") || (context === "explicit" && sourceCategory === "string"))) {
+        return true;
+    }
+    if (postgresCatalogCanCast(sourceType, targetType, context, schema))
+        return true;
+    const cast = postgresExtensionCasts(schema).find((candidate) => postgresCanonicalType(candidate.sourceType, schema) === sourceType &&
+        postgresCanonicalType(candidate.targetType, schema) === targetType);
+    return (cast !== undefined &&
+        (context === "explicit" ||
+            cast.context === "implicit" ||
+            (context === "assignment" && cast.context === "assignment")));
+}
+function bindExact(binding, value) {
+    return binding === undefined || binding === value ? value : false;
+}
+function bindPolymorphic(declared, actual, bindings, compatibleInputs, schema) {
+    if (actual === undefined)
+        return true;
+    const canonical = postgresCanonicalType(actual, schema);
+    if (simplePolymorphicTypes.has(declared)) {
+        if (declared === "anyarray") {
+            const element = elementType(canonical, schema);
+            if (element === undefined)
+                return false;
+            const array = bindExact(bindings.simpleArray, canonical);
+            const simple = bindExact(bindings.simple, element);
+            if (array === false || simple === false)
+                return false;
+            bindings.simpleArray = array;
+            bindings.simple = simple;
+            return true;
+        }
+        if (declared === "anyrange" || declared === "anymultirange") {
+            const subtype = rangeSubtype(canonical, schema);
+            if (subtype === undefined)
+                return false;
+            const key = declared === "anyrange" ? "simpleRange" : "simpleMultirange";
+            const range = bindExact(bindings[key], canonical);
+            const simple = bindExact(bindings.simple, subtype);
+            if (range === false || simple === false)
+                return false;
+            bindings[key] = range;
+            bindings.simple = simple;
+            return true;
+        }
+        if (declared === "anynonarray" && elementType(canonical, schema) !== undefined)
+            return false;
+        if (declared === "anyenum" && category(canonical, schema) !== "enum")
+            return false;
+        const simple = bindExact(bindings.simple, canonical);
+        if (simple === false)
+            return false;
+        bindings.simple = simple;
+        return true;
+    }
+    if (!compatiblePolymorphicTypes.has(declared))
+        return false;
+    if (declared === "anycompatiblearray") {
+        const element = elementType(canonical, schema);
+        if (element === undefined)
+            return false;
+        compatibleInputs.push(element);
+        bindings.compatibleArray = canonical;
+        return true;
+    }
+    if (declared === "anycompatiblerange" || declared === "anycompatiblemultirange") {
+        const subtype = rangeSubtype(canonical, schema);
+        if (subtype === undefined)
+            return false;
+        compatibleInputs.push(subtype);
+        const key = declared === "anycompatiblerange" ? "compatibleRange" : "compatibleMultirange";
+        const current = bindExact(bindings[key], canonical);
+        if (current === false)
+            return false;
+        bindings[key] = current;
+        return true;
+    }
+    if (declared === "anycompatiblenonarray" && elementType(canonical, schema) !== undefined)
+        return false;
+    compatibleInputs.push(canonical);
+    return true;
+}
+function instantiate(declared, bindings) {
+    if (declared === "anyelement" || declared === "anynonarray" || declared === "anyenum")
+        return bindings.simple;
+    if (declared === "anyarray")
+        return bindings.simpleArray ?? (bindings.simple === undefined ? undefined : `${bindings.simple}[]`);
+    if (declared === "anyrange")
+        return bindings.simpleRange;
+    if (declared === "anymultirange")
+        return bindings.simpleMultirange;
+    if (declared === "anycompatible" || declared === "anycompatiblenonarray")
+        return bindings.compatible;
+    if (declared === "anycompatiblearray")
+        return bindings.compatible === undefined ? bindings.compatibleArray : `${bindings.compatible}[]`;
+    if (declared === "anycompatiblerange")
+        return bindings.compatibleRange;
+    if (declared === "anycompatiblemultirange")
+        return bindings.compatibleMultirange;
+    return declared;
+}
+function rankCandidate(candidate, actualTypes, schema) {
+    if (candidate.argumentTypes.length !== actualTypes.length)
+        return undefined;
+    const bindings = {};
+    const compatibleInputs = [];
+    let exact = 0;
+    let preferred = 0;
+    let unknownString = 0;
+    for (const [index, declaredValue] of candidate.argumentTypes.entries()) {
+        const declared = postgresCanonicalType(declaredValue, schema);
+        const actualValue = actualTypes[index];
+        const actual = actualValue === undefined ? undefined : postgresCanonicalType(actualValue, schema);
+        if (simplePolymorphicTypes.has(declared) || compatiblePolymorphicTypes.has(declared)) {
+            if (!bindPolymorphic(declared, actual, bindings, compatibleInputs, schema))
+                return undefined;
+            continue;
+        }
+        if (actual === undefined) {
+            if (category(declared, schema) === "string")
+                unknownString += 1;
+            if (isPreferred(declared, schema))
+                preferred += 1;
+            continue;
+        }
+        if (baseType(actual, schema) === baseType(declared, schema))
+            exact += 1;
+        else if (!postgresCanCoerce(actual, declared, "implicit", schema))
+            return undefined;
+        else if (isPreferred(declared, schema))
+            preferred += 1;
+    }
+    if (compatibleInputs.length > 0 ||
+        candidate.argumentTypes.some((type) => compatiblePolymorphicTypes.has(normalize(type)))) {
+        const common = postgresCommonType(compatibleInputs.length === 0 ? [undefined] : compatibleInputs, schema);
+        if (common === undefined)
+            return undefined;
+        bindings.compatible = common;
+    }
+    const argumentTypes = candidate.argumentTypes.map((declared) => instantiate(declared, bindings) ?? declared);
+    const resultType = instantiate(candidate.resultType, bindings);
+    if (resultType === undefined)
+        return undefined;
+    return { kind: "selected", candidate: candidate.value, argumentTypes, resultType, exact, preferred, unknownString };
+}
+/** Selects a PostgreSQL overload using exact, implicit-cast, preferred-type, and unknown-category evidence. */
+export function resolvePostgresCandidates(candidates, actualTypes, schema) {
+    let matches = candidates
+        .map((candidate) => rankCandidate(candidate, actualTypes, schema))
+        .filter((candidate) => candidate !== undefined);
+    if (matches.length === 0)
+        return { kind: "none" };
+    for (const [index, actual] of actualTypes.entries()) {
+        if (actual !== undefined)
+            continue;
+        const categories = new Set(matches
+            .map((candidate) => category(candidate.argumentTypes[index], schema))
+            .filter((candidate) => candidate !== undefined));
+        const selectedCategory = categories.has("string")
+            ? "string"
+            : categories.size === 1
+                ? [...categories][0]
+                : undefined;
+        if (selectedCategory === undefined)
+            return { kind: "ambiguous" };
+        matches = matches.filter((candidate) => category(candidate.argumentTypes[index], schema) === selectedCategory);
+        const preferred = matches.filter((candidate) => isPreferred(candidate.argumentTypes[index], schema));
+        if (preferred.length > 0)
+            matches = preferred;
+        if (matches.length === 1)
+            return matches[0];
+    }
+    for (const score of ["exact", "preferred", "unknownString"]) {
+        const maximum = Math.max(...matches.map((candidate) => candidate[score]));
+        if (maximum > 0)
+            matches = matches.filter((candidate) => candidate[score] === maximum);
+        if (matches.length === 1)
+            return matches[0];
+    }
+    const known = actualTypes
+        .filter((value) => value !== undefined)
+        .map((value) => baseType(value, schema));
+    if (known.length > 0 && known.every((value) => value === known[0])) {
+        const sameType = matches.filter((candidate) => candidate.argumentTypes.every((declared, index) => actualTypes[index] !== undefined || declared === known[0]));
+        if (sameType.length === 1)
+            return sameType[0];
+    }
+    return { kind: "ambiguous" };
+}
+function categoryPairs(categoryName, schema) {
+    const types = postgresCoreCatalogForSchema(schema)
+        .types.filter(({ category: candidateCategory }) => candidateCategory === categoryName)
+        .map(({ name }) => name);
+    return types.flatMap((left) => types.flatMap((right) => {
+        const result = postgresCommonType([left, right], schema);
+        return result === undefined ? [] : [[left, right, result]];
+    }));
+}
+function categoryTypes(categoryName, schema) {
+    return postgresCoreCatalogForSchema(schema)
+        .types.filter(({ category: candidateCategory }) => candidateCategory === categoryName)
+        .map(({ name }) => name);
+}
+function numericOperatorCandidates(operator) {
+    const candidates = [];
+    const add = (left, right, resultType) => {
+        candidates.push({ value: operator, argumentTypes: [left, right], resultType });
+    };
+    const integral = ["smallint", "integer", "bigint"];
+    const integralResult = (left, right) => integral[Math.max(integral.indexOf(left), integral.indexOf(right))];
+    if (["+", "-", "*", "/"].includes(operator)) {
+        for (const left of integral) {
+            for (const right of integral)
+                add(left, right, integralResult(left, right));
+        }
+        add("real", "real", "real");
+        add("real", "double precision", "double precision");
+        add("double precision", "real", "double precision");
+        add("double precision", "double precision", "double precision");
+        add("numeric", "numeric", "numeric");
+    }
+    else if (operator === "%") {
+        for (const type of integral)
+            add(type, type, type);
+        add("numeric", "numeric", "numeric");
+    }
+    else if (operator === "^") {
+        add("numeric", "numeric", "numeric");
+        add("double precision", "double precision", "double precision");
+    }
+    return candidates;
+}
+function temporalOperatorCandidates(operator) {
+    const candidates = [];
+    const add = (left, right, resultType) => {
+        candidates.push({ value: operator, argumentTypes: [left, right], resultType });
+    };
+    if (operator === "+") {
+        add("date", "integer", "date");
+        add("integer", "date", "date");
+        for (const type of ["timestamp", "timestamptz", "time"]) {
+            add(type, "interval", type);
+            add("interval", type, type);
+        }
+        add("interval", "interval", "interval");
+    }
+    else if (operator === "-") {
+        add("date", "integer", "date");
+        add("date", "date", "integer");
+        for (const type of ["timestamp", "timestamptz", "time"]) {
+            add(type, type, "interval");
+            add(type, "interval", type);
+        }
+        add("interval", "interval", "interval");
+    }
+    else if (operator === "*") {
+        for (const numeric of numericOperatorTypes) {
+            add("interval", numeric, "interval");
+            add(numeric, "interval", "interval");
+        }
+    }
+    else if (operator === "/") {
+        for (const numeric of numericOperatorTypes)
+            add("interval", numeric, "interval");
+    }
+    return candidates;
+}
+const builtInRangeFamilies = [
+    ["int4range", "int4multirange", "integer"],
+    ["int8range", "int8multirange", "bigint"],
+    ["numrange", "nummultirange", "numeric"],
+    ["tsrange", "tsmultirange", "timestamp"],
+    ["tstzrange", "tstzmultirange", "timestamptz"],
+    ["daterange", "datemultirange", "date"],
+];
+function specialOperatorCandidates(operator) {
+    const candidates = [];
+    const add = (left, right, resultType) => {
+        if (candidates.some((candidate) => candidate.argumentTypes[0] === left &&
+            candidate.argumentTypes[1] === right &&
+            candidate.resultType === resultType))
+            return;
+        candidates.push({ value: operator, argumentTypes: [left, right], resultType });
+    };
+    for (const [range, multirange, element] of builtInRangeFamilies) {
+        if (operator === "@>") {
+            for (const [left, right] of [
+                [range, range],
+                [range, element],
+                [range, multirange],
+                [multirange, multirange],
+                [multirange, range],
+                [multirange, element],
+            ])
+                add(left, right, "boolean");
+        }
+        else if (operator === "<@") {
+            for (const [left, right] of [
+                [range, range],
+                [element, range],
+                [multirange, multirange],
+                [multirange, range],
+                [range, multirange],
+                [element, multirange],
+            ])
+                add(left, right, "boolean");
+        }
+        else if (["&&", "<<", ">>", "&<", "&>"].includes(operator)) {
+            for (const [left, right] of [
+                [range, range],
+                [multirange, multirange],
+                [range, multirange],
+                [multirange, range],
+            ])
+                add(left, right, "boolean");
+        }
+        else if (operator === "-\u007c-") {
+            for (const [left, right] of [
+                [range, range],
+                [multirange, multirange],
+                [range, multirange],
+                [multirange, range],
+            ])
+                add(left, right, "boolean");
+        }
+        else if (["+", "*", "-"].includes(operator)) {
+            add(range, range, range);
+            add(multirange, multirange, multirange);
+        }
+    }
+    const geometric = ["point", "box", "lseg", "line", "path", "polygon", "circle"];
+    const sameGeometric = (types, resultType) => {
+        for (const type of types)
+            add(type, type, resultType);
+    };
+    if (["+", "-", "*", "/"].includes(operator)) {
+        for (const type of ["point", "box", "path", "circle"])
+            add(type, "point", type);
+        if (operator === "+")
+            add("path", "path", "path");
+    }
+    else if (operator === "#") {
+        add("lseg", "lseg", "point");
+        add("line", "line", "point");
+        add("box", "box", "box");
+    }
+    else if (operator === "##") {
+        for (const [left, right] of [
+            ["point", "box"],
+            ["point", "lseg"],
+            ["point", "line"],
+            ["lseg", "box"],
+            ["lseg", "lseg"],
+            ["line", "lseg"],
+        ])
+            add(left, right, "point");
+    }
+    else if (operator === "<->") {
+        sameGeometric(geometric, "double precision");
+        for (const type of geometric) {
+            add("point", type, "double precision");
+            add(type, "point", "double precision");
+        }
+        for (const [left, right] of [
+            ["box", "lseg"],
+            ["lseg", "line"],
+            ["polygon", "circle"],
+        ]) {
+            add(left, right, "double precision");
+            add(right, left, "double precision");
+        }
+    }
+    else if (operator === "@>") {
+        for (const [left, right] of [
+            ["box", "point"],
+            ["box", "box"],
+            ["path", "point"],
+            ["polygon", "point"],
+            ["polygon", "polygon"],
+            ["circle", "point"],
+            ["circle", "circle"],
+        ])
+            add(left, right, "boolean");
+    }
+    else if (operator === "<@") {
+        for (const [left, right] of [
+            ["point", "box"],
+            ["point", "lseg"],
+            ["point", "line"],
+            ["point", "path"],
+            ["point", "polygon"],
+            ["point", "circle"],
+            ["box", "box"],
+            ["lseg", "box"],
+            ["lseg", "line"],
+            ["polygon", "polygon"],
+            ["circle", "circle"],
+        ])
+            add(left, right, "boolean");
+    }
+    else if (operator === "&&")
+        sameGeometric(["box", "polygon", "circle"], "boolean");
+    else if (operator === "<<" || operator === ">>")
+        sameGeometric(["point", "box", "polygon", "circle"], "boolean");
+    else if (["&<", "&>", "&<|", "|&>"].includes(operator))
+        sameGeometric(["box", "polygon", "circle"], "boolean");
+    else if (operator === "<<|" || operator === "|>>")
+        sameGeometric(["point", "box", "polygon", "circle"], "boolean");
+    else if (operator === "<^" || operator === ">^") {
+        add("box", "box", "boolean");
+        add("point", "point", "boolean");
+    }
+    else if (operator === "?#") {
+        for (const [left, right] of [
+            ["box", "box"],
+            ["lseg", "box"],
+            ["lseg", "lseg"],
+            ["lseg", "line"],
+            ["line", "box"],
+            ["line", "line"],
+            ["path", "path"],
+        ])
+            add(left, right, "boolean");
+    }
+    else if (operator === "?-" || operator === "?|")
+        add("point", "point", "boolean");
+    else if (operator === "?-|" || operator === "?||")
+        sameGeometric(["line", "lseg"], "boolean");
+    else if (operator === "~=")
+        sameGeometric(["point", "box", "polygon", "circle"], "boolean");
+    if (operator === "<<" || operator === ">>") {
+        for (const type of ["smallint", "integer", "bigint"])
+            add(type, "integer", type);
+        add("bit", "integer", "bit");
+    }
+    if (["<<", "<<=", ">>", ">>=", "&&"].includes(operator))
+        add("inet", "inet", "boolean");
+    if (operator === "&" || operator === "|") {
+        add("inet", "inet", "inet");
+        add("macaddr", "macaddr", "macaddr");
+        add("macaddr8", "macaddr8", "macaddr8");
+    }
+    if (operator === "+") {
+        add("inet", "bigint", "inet");
+        add("bigint", "inet", "inet");
+        add("money", "money", "money");
+        add("pg_lsn", "numeric", "pg_lsn");
+        add("numeric", "pg_lsn", "pg_lsn");
+    }
+    else if (operator === "-") {
+        add("inet", "bigint", "inet");
+        add("inet", "inet", "bigint");
+        add("jsonb", "text", "jsonb");
+        add("jsonb", "text[]", "jsonb");
+        add("jsonb", "integer", "jsonb");
+        add("money", "money", "money");
+        add("pg_lsn", "numeric", "pg_lsn");
+        add("pg_lsn", "pg_lsn", "numeric");
+    }
+    else if (operator === "*") {
+        for (const numeric of ["smallint", "integer", "bigint", "real", "double precision"]) {
+            add("money", numeric, "money");
+            add(numeric, "money", "money");
+        }
+    }
+    else if (operator === "/") {
+        for (const numeric of ["smallint", "integer", "bigint", "real", "double precision"])
+            add("money", numeric, "money");
+        add("money", "money", "double precision");
+    }
+    else if (operator === "#-")
+        add("jsonb", "text[]", "jsonb");
+    else if (operator === "@?")
+        add("jsonb", "jsonpath", "boolean");
+    else if (operator === "@@") {
+        add("jsonb", "jsonpath", "boolean");
+        add("tsvector", "tsquery", "boolean");
+        add("tsquery", "tsvector", "boolean");
+        add("text", "tsquery", "boolean");
+    }
+    else if (operator === "&&")
+        add("tsquery", "tsquery", "tsquery");
+    else if (operator === "||") {
+        add("text", "anynonarray", "text");
+        add("anynonarray", "text", "text");
+        add("bytea", "bytea", "bytea");
+        add("varbit", "varbit", "varbit");
+        add("jsonb", "jsonb", "jsonb");
+        add("tsvector", "tsvector", "tsvector");
+        add("tsquery", "tsquery", "tsquery");
+    }
+    else if (operator === "^@")
+        add("text", "text", "boolean");
+    if (comparisonOperators.has(operator)) {
+        add("tsvector", "tsvector", "boolean");
+        add("tsquery", "tsquery", "boolean");
+    }
+    return candidates;
+}
+function operatorCandidates(operator, schema) {
+    const cache = schema === undefined
+        ? defaultOperatorCandidates
+        : (operatorCandidatesBySchema.get(schema) ??
+            (() => {
+                const created = new Map();
+                operatorCandidatesBySchema.set(schema, created);
+                return created;
+            })());
+    const cached = cache.get(operator);
+    if (cached !== undefined)
+        return cached;
+    const extension = postgresExtensionOperators(schema)
+        .filter((candidate) => candidate.name.toUpperCase() === operator && candidate.argumentTypes.length === 2)
+        .map((candidate) => ({
+        value: operator,
+        argumentTypes: candidate.argumentTypes,
+        resultType: candidate.resultType,
+    }));
+    const rule = postgresCatalogOperatorRule(operator, schema);
+    const special = specialOperatorCandidates(operator);
+    let candidates;
+    if (rule === "numeric")
+        candidates = [
+            ...numericOperatorCandidates(operator),
+            ...temporalOperatorCandidates(operator),
+            ...special,
+            ...extension,
+        ];
+    else if (rule === "bitwise") {
+        candidates = [
+            ...["smallint", "integer", "bigint"].map((type) => ({
+                value: operator,
+                argumentTypes: [type, type],
+                resultType: type,
+            })),
+            { value: operator, argumentTypes: ["bit", "bit"], resultType: "bit" },
+            ...special,
+            ...extension,
+        ];
+    }
+    else if (rule === "concatenation") {
+        candidates = [
+            { value: operator, argumentTypes: ["text", "text"], resultType: "text" },
+            {
+                value: operator,
+                argumentTypes: ["anycompatiblearray", "anycompatiblearray"],
+                resultType: "anycompatiblearray",
+            },
+            { value: operator, argumentTypes: ["anycompatible", "anycompatiblearray"], resultType: "anycompatiblearray" },
+            { value: operator, argumentTypes: ["anycompatiblearray", "anycompatible"], resultType: "anycompatiblearray" },
+            ...special,
+            ...extension,
+        ];
+    }
+    else if (rule === "json" || rule === "json-text") {
+        const result = rule === "json-text" ? "text" : undefined;
+        const path = operator.startsWith("#") ? "text[]" : undefined;
+        candidates = [
+            ...["json", "jsonb"].flatMap((left) => (path === undefined ? ["integer", "text"] : [path]).map((right) => ({
+                value: operator,
+                argumentTypes: [left, right],
+                resultType: result ?? left,
+            }))),
+            ...special,
+            ...extension,
+        ];
+    }
+    else if (rule === "special" || rule !== "boolean")
+        candidates = [...special, ...extension];
+    else if (operator === "AND" || operator === "OR") {
+        candidates = [
+            { value: operator, argumentTypes: ["boolean", "boolean"], resultType: "boolean" },
+            ...special,
+            ...extension,
+        ];
+    }
+    else if (patternOperators.has(operator)) {
+        candidates = [
+            { value: operator, argumentTypes: ["text", "text"], resultType: "boolean" },
+            ...special,
+            ...extension,
+        ];
+    }
+    else if (operator === "?" || operator === "?&" || operator === "?|") {
+        candidates = [
+            {
+                value: operator,
+                argumentTypes: ["jsonb", operator === "?" ? "text" : "text[]"],
+                resultType: "boolean",
+            },
+            ...special,
+            ...extension,
+        ];
+    }
+    else if (operator === "@>" || operator === "<@" || operator === "&&") {
+        candidates = [
+            { value: operator, argumentTypes: ["anyarray", "anyarray"], resultType: "boolean" },
+            ...(operator === "&&" ? [] : [{ value: operator, argumentTypes: ["jsonb", "jsonb"], resultType: "boolean" }]),
+            ...special,
+            ...extension,
+        ];
+    }
+    else if (!comparisonOperators.has(operator))
+        candidates = extension;
+    else {
+        const categoryCandidates = ["numeric", "string", "datetime", "timespan", "bit-string", "network", "range"].flatMap((categoryName) => categoryPairs(categoryName, schema).map(([left, right]) => ({
+            value: operator,
+            argumentTypes: [left, right],
+            resultType: "boolean",
+        })));
+        candidates = [
+            ...categoryCandidates,
+            { value: operator, argumentTypes: ["boolean", "boolean"], resultType: "boolean" },
+            { value: operator, argumentTypes: ["uuid", "uuid"], resultType: "boolean" },
+            { value: operator, argumentTypes: ["bytea", "bytea"], resultType: "boolean" },
+            { value: operator, argumentTypes: ["jsonb", "jsonb"], resultType: "boolean" },
+            { value: operator, argumentTypes: ["pg_lsn", "pg_lsn"], resultType: "boolean" },
+            { value: operator, argumentTypes: ["tid", "tid"], resultType: "boolean" },
+            { value: operator, argumentTypes: ["anyenum", "anyenum"], resultType: "boolean" },
+            { value: operator, argumentTypes: ["anyarray", "anyarray"], resultType: "boolean" },
+            ...special,
+            ...extension,
+        ];
+    }
+    cache.set(operator, candidates);
+    return candidates;
+}
+/** Resolves PostgreSQL prefix operators through grammar-owned operator candidates. */
+export function resolvePostgresUnaryOperator(operator, operand, schema) {
+    const normalizedOperator = operator.toUpperCase();
+    const builtins = normalizedOperator === "NOT"
+        ? [{ value: normalizedOperator, argumentTypes: ["boolean"], resultType: "boolean" }]
+        : normalizedOperator === "+" || normalizedOperator === "-"
+            ? categoryTypes("numeric", schema)
+                .filter((type) => numericOperatorTypes.has(type))
+                .map((type) => ({
+                value: normalizedOperator,
+                argumentTypes: [type],
+                resultType: type,
+            }))
+            : normalizedOperator === "~"
+                ? ["smallint", "integer", "bigint", "bit", "inet", "macaddr", "macaddr8"].map((type) => ({
+                    value: normalizedOperator,
+                    argumentTypes: [type],
+                    resultType: type,
+                }))
+                : normalizedOperator === "!!"
+                    ? [{ value: normalizedOperator, argumentTypes: ["tsquery"], resultType: "tsquery" }]
+                    : normalizedOperator === "@"
+                        ? [...numericOperatorTypes].map((type) => ({
+                            value: normalizedOperator,
+                            argumentTypes: [type],
+                            resultType: type,
+                        }))
+                        : normalizedOperator === "|/" || normalizedOperator === "||/"
+                            ? [
+                                {
+                                    value: normalizedOperator,
+                                    argumentTypes: ["double precision"],
+                                    resultType: "double precision",
+                                },
+                            ]
+                            : normalizedOperator === "@-@"
+                                ? ["lseg", "path"].map((type) => ({
+                                    value: normalizedOperator,
+                                    argumentTypes: [type],
+                                    resultType: "double precision",
+                                }))
+                                : normalizedOperator === "@@"
+                                    ? ["box", "lseg", "polygon", "circle"].map((type) => ({
+                                        value: normalizedOperator,
+                                        argumentTypes: [type],
+                                        resultType: "point",
+                                    }))
+                                    : normalizedOperator === "#"
+                                        ? ["path", "polygon"].map((type) => ({
+                                            value: normalizedOperator,
+                                            argumentTypes: [type],
+                                            resultType: "integer",
+                                        }))
+                                        : normalizedOperator === "?-" || normalizedOperator === "?|"
+                                            ? ["line", "lseg"].map((type) => ({
+                                                value: normalizedOperator,
+                                                argumentTypes: [type],
+                                                resultType: "boolean",
+                                            }))
+                                            : [];
+    const extension = postgresExtensionOperators(schema)
+        .filter((candidate) => candidate.name.toUpperCase() === normalizedOperator && candidate.argumentTypes.length === 1)
+        .map((candidate) => ({
+        value: normalizedOperator,
+        argumentTypes: candidate.argumentTypes,
+        resultType: candidate.resultType,
+    }));
+    const candidates = [...builtins, ...extension];
+    if (operand === undefined && candidates.length !== 1) {
+        return candidates.length === 0 ? { kind: "none" } : { kind: "ambiguous" };
+    }
+    return resolvePostgresCandidates(candidates, [operand], schema);
+}
+/** Resolves built-in binary operators through the same candidate machinery as routine calls. */
+export function resolvePostgresOperator(operator, left, right, schema) {
+    const normalizedOperator = operator.toUpperCase();
+    const cache = schema === undefined
+        ? defaultOperatorResolutions
+        : (operatorResolutionsBySchema.get(schema) ??
+            (() => {
+                const created = new Map();
+                operatorResolutionsBySchema.set(schema, created);
+                return created;
+            })());
+    const cacheKey = `${normalizedOperator}\0${left ?? "?"}\0${right ?? "?"}`;
+    const cached = cache.get(cacheKey);
+    if (cached !== undefined)
+        return cached;
+    const candidates = operatorCandidates(normalizedOperator, schema);
+    let inputs = [left, right];
+    if (left === undefined && right !== undefined)
+        inputs = [right, right];
+    else if (right === undefined && left !== undefined)
+        inputs = [left, left];
+    const assumedExact = resolvePostgresCandidates(candidates, inputs, schema);
+    const resolved = assumedExact.kind === "selected" || (left !== undefined && right !== undefined)
+        ? assumedExact
+        : resolvePostgresCandidates(candidates, [left, right], schema);
+    cache.set(cacheKey, resolved);
+    return resolved;
+}
+//# sourceMappingURL=type-resolution.js.map