joist-core 2.3.0 → 2.4.0-next.2

package/build/queries/sql/expressions/codecs.js

@@ -0,0 +1,125 @@
+import { arrayOutputType } from "../../../serde/TypeInfo.js";
+import { BaseExpr } from "../Expr.js";
+import { assertNever } from "../../../utils.js";
+import { inspect } from "node:util";
+//#region src/queries/sql/expressions/codecs.ts
+/**
+* Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;
+* literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,
+* but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.
+*/
+function chooseExpressionCodec(parsed) {
+	const leaves = expressionLeaves(parsed);
+	const expressions = leaves.flatMap((leaf) => "codec" in leaf ? [leaf.codec] : []);
+	const first = expressions[0];
+	if (first) {
+		for (const other of expressions.slice(1)) {
+			if (other === first) continue;
+			const a = first.outputType;
+			const b = other.outputType;
+			if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {
+				const mismatches = !a || !b ? ["unknown codec"] : [
+					...!compatibleDbTypes(a.dbType, b.dbType) ? ["SQL type"] : [],
+					...a.domain !== b.domain ? ["domain"] : [],
+					...a.idMeta !== b.idMeta ? ["ID target"] : []
+				];
+				throw new Error(`Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(", ")}`);
+			}
+		}
+		for (const leaf of leaves) if ("literal" in leaf) checkLiteral(leaf.literal.value, first.outputType);
+		return first;
+	}
+	const literals = leaves.flatMap((leaf) => "literal" in leaf ? [leaf.literal] : []);
+	const types = literals.map((v) => literalType(v.value)).filter((v) => v !== void 0);
+	for (const literal of literals) checkLiteral(literal.value, types[0]);
+	return new LiteralCodec(types[0] ?? {
+		dbType: "text",
+		domain: String
+	});
+}
+/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */
+var LiteralCodec = class {
+	outputType;
+	constructor(outputType) {
+		this.outputType = outputType;
+	}
+	encode(value) {
+		return value;
+	}
+	decode(value) {
+		return this.outputType.domain === BigInt ? BigInt(value) : value;
+	}
+};
+/**
+* Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.
+* Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.
+*/
+function expressionLeaves(parsed) {
+	if (parsed instanceof BaseExpr) return [{ codec: parsed }];
+	switch (parsed.kind) {
+		case "literal": return [{ literal: parsed }];
+		case "arrayAgg": {
+			const valueCodec = chooseExpressionCodec(parsed.value);
+			return [{ codec: {
+				outputType: arrayOutputType(valueCodec.outputType),
+				encode: (value) => Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value,
+				decode: (value) => Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value
+			} }];
+		}
+		case "coalesce": return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));
+		case "nullIf": return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];
+		case "greatest":
+		case "least": return parsed.values.flatMap((value) => expressionLeaves(value));
+		case "case": return [...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)), ...parsed.else ? expressionLeaves(parsed.else) : []];
+		default: return assertNever(parsed);
+	}
+}
+/** Supplies predictable PostgreSQL types for standalone primitive literals. */
+function literalType(value) {
+	if (value === null) return void 0;
+	if (typeof value === "string") return {
+		dbType: "text",
+		domain: String,
+		arrayElementSafe: true
+	};
+	if (typeof value === "number") return {
+		dbType: "float8",
+		domain: Number,
+		arrayElementSafe: true
+	};
+	if (typeof value === "boolean") return {
+		dbType: "bool",
+		domain: Boolean,
+		arrayElementSafe: true
+	};
+	if (typeof value === "bigint") return {
+		dbType: "int8",
+		domain: BigInt
+	};
+	if (value instanceof Date) return {
+		dbType: "timestamptz",
+		domain: Date
+	};
+	throw new Error("Object and array literals need an expression with a matching codec");
+}
+/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */
+function checkLiteral(value, type) {
+	if (value === null || !type) return;
+	const domain = type.domain;
+	if (domain === String && typeof value !== "string" || domain === Number && typeof value !== "number" || domain === Boolean && typeof value !== "boolean" || domain === BigInt && typeof value !== "bigint" || domain === Date && !(value instanceof Date)) throw new Error(`Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`);
+}
+/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */
+function describeType(type) {
+	if (!type) return "unknown codec";
+	const domain = typeof type.domain === "function" ? type.domain.name : inspect(type.domain, { depth: 0 });
+	return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : ""})`;
+}
+const compatibleStringDbTypes = /* @__PURE__ */ new Set(["text", "varchar"]);
+/** Allows PostgreSQL scalar string types that resolve to a common string result. */
+function compatibleDbTypes(a, b) {
+	return a === b || compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b);
+}
+//#endregion
+export { chooseExpressionCodec };
+
+//# sourceMappingURL=codecs.js.map

package/build/queries/sql/expressions/codecs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codecs.js","names":[],"sources":["../../../../src/queries/sql/expressions/codecs.ts"],"sourcesContent":["import { inspect } from \"node:util\";\n\nimport { BaseExpr } from \"src/queries/sql/Expr.ts\";\nimport type { ParsedExpression, ParsedLiteralExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\nimport { type TypeInfo, arrayOutputType } from \"src/serde/TypeInfo.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\n/**\n * Chooses one decoder for all possible result values. Columns must agree on a compatible SQL type and domain;\n * literals use that column's encoder. This is conservative: PostgreSQL may accept other combinations,\n * but Joist cannot safely choose their decoder. I.e. Author.id and Book.id both store integers but use different tags.\n */\nexport function chooseExpressionCodec(parsed: ParsedExpression): ResultCodec {\n  const leaves = expressionLeaves(parsed);\n  const expressions = leaves.flatMap((leaf) => (\"codec\" in leaf ? [leaf.codec] : []));\n  const first = expressions[0];\n  if (first) {\n    for (const other of expressions.slice(1)) {\n      if (other === first) continue;\n      const a = first.outputType;\n      const b = other.outputType;\n      if (!a || !b || !compatibleDbTypes(a.dbType, b.dbType) || a.domain !== b.domain || a.idMeta !== b.idMeta) {\n        const mismatches =\n          !a || !b\n            ? [\"unknown codec\"]\n            : [\n                ...(!compatibleDbTypes(a.dbType, b.dbType) ? [\"SQL type\"] : []),\n                ...(a.domain !== b.domain ? [\"domain\"] : []),\n                ...(a.idMeta !== b.idMeta ? [\"ID target\"] : []),\n              ];\n        throw new Error(\n          `Expression operands need matching SQL types and codecs: ${describeType(a)} vs ${describeType(b)}; mismatched ${mismatches.join(\", \")}`,\n        );\n      }\n    }\n    for (const leaf of leaves) if (\"literal\" in leaf) checkLiteral(leaf.literal.value, first.outputType);\n    return first;\n  }\n  const literals = leaves.flatMap((leaf) => (\"literal\" in leaf ? [leaf.literal] : []));\n  const types = literals.map((v) => literalType(v.value)).filter((v) => v !== undefined);\n  for (const literal of literals) checkLiteral(literal.value, types[0]);\n  return new LiteralCodec(types[0] ?? { dbType: \"text\", domain: String });\n}\n\n/** Gives literal-only expressions a SQL type so PostgreSQL does not return numbers as text. */\nclass LiteralCodec {\n  constructor(readonly outputType: TypeInfo) {}\n\n  encode(value: unknown): unknown {\n    return value;\n  }\n\n  decode(value: unknown): unknown {\n    return this.outputType.domain === BigInt ? BigInt(value as string) : value;\n  }\n}\n\n/**\n * Finds parsed operands that share a codec, including NULLIF's comparison operand but not CASE conditions.\n * Each kind selects its own value fields; only CASE's THEN and ELSE expressions contribute a result codec.\n */\nfunction expressionLeaves(parsed: ParsedExpression): CodecLeaf[] {\n  if (parsed instanceof BaseExpr) return [{ codec: parsed }];\n  switch (parsed.kind) {\n    case \"literal\":\n      return [{ literal: parsed }];\n    case \"arrayAgg\": {\n      const valueCodec = chooseExpressionCodec(parsed.value);\n      return [\n        {\n          codec: {\n            outputType: arrayOutputType(valueCodec.outputType),\n            encode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.encode(element)) : value),\n            decode: (value) => (Array.isArray(value) ? value.map((element) => valueCodec.decode(element)) : value),\n          },\n        },\n      ];\n    }\n    case \"coalesce\":\n      return parsed.candidates.flatMap((candidate) => expressionLeaves(candidate));\n    case \"nullIf\":\n      return [...expressionLeaves(parsed.value), ...expressionLeaves(parsed.equals)];\n    case \"greatest\":\n    case \"least\":\n      return parsed.values.flatMap((value) => expressionLeaves(value));\n    case \"case\":\n      return [\n        ...parsed.whens.flatMap((entry) => expressionLeaves(entry.then)),\n        ...(parsed.else ? expressionLeaves(parsed.else) : []),\n      ];\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** One result codec or one literal that will adopt a sibling codec. */\ntype CodecLeaf = { codec: ResultCodec } | { literal: ParsedLiteralExpression };\n\n/** Supplies predictable PostgreSQL types for standalone primitive literals. */\nfunction literalType(value: unknown): TypeInfo | undefined {\n  if (value === null) return undefined;\n  if (typeof value === \"string\") return { dbType: \"text\", domain: String, arrayElementSafe: true };\n  if (typeof value === \"number\") return { dbType: \"float8\", domain: Number, arrayElementSafe: true };\n  if (typeof value === \"boolean\") return { dbType: \"bool\", domain: Boolean, arrayElementSafe: true };\n  if (typeof value === \"bigint\") return { dbType: \"int8\", domain: BigInt };\n  if (value instanceof Date) return { dbType: \"timestamptz\", domain: Date };\n  throw new Error(\"Object and array literals need an expression with a matching codec\");\n}\n\n/** Rejects primitive literals that disagree with the column; custom values are checked by their encoder. */\nfunction checkLiteral(value: unknown, type: TypeInfo | undefined): void {\n  if (value === null || !type) return;\n  const domain = type.domain;\n  if (\n    (domain === String && typeof value !== \"string\") ||\n    (domain === Number && typeof value !== \"number\") ||\n    (domain === Boolean && typeof value !== \"boolean\") ||\n    (domain === BigInt && typeof value !== \"bigint\") ||\n    (domain === Date && !(value instanceof Date))\n  ) {\n    throw new Error(\n      `Expression values must have compatible types: expected ${describeType(type)}, got ${inspect(value)} (${typeof value})`,\n    );\n  }\n}\n\n/** Names the storage type, conversion domain, and entity tag involved in a codec mismatch. */\nfunction describeType(type: TypeInfo | undefined): string {\n  if (!type) return \"unknown codec\";\n  const domain = typeof type.domain === \"function\" ? type.domain.name : inspect(type.domain, { depth: 0 });\n  return `${type.dbType} (domain ${domain}${type.idMeta ? `, ID target ${type.idMeta.type}` : \"\"})`;\n}\n\nconst compatibleStringDbTypes = new Set([\"text\", \"varchar\"]);\n\n/** Allows PostgreSQL scalar string types that resolve to a common string result. */\nfunction compatibleDbTypes(a: string, b: string): boolean {\n  return a === b || (compatibleStringDbTypes.has(a) && compatibleStringDbTypes.has(b));\n}\n"],"mappings":"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"}

package/build/queries/sql/expressions/expression.cjs

@@ -0,0 +1,102 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_queries_sql_Expr = require("../Expr.cjs");
+const require_utils = require("../../../utils.cjs");
+const require_queries_sql_expressions_case = require("./case.cjs");
+const require_queries_sql_expressions_coalesce = require("./coalesce.cjs");
+const require_queries_sql_expressions_greatest = require("./greatest.cjs");
+const require_queries_sql_expressions_least = require("./least.cjs");
+const require_queries_sql_expressions_nullIf = require("./nullIf.cjs");
+const require_queries_sql_expressions_parseExpression = require("./parseExpression.cjs");
+const require_queries_sql_expressions_arrayAgg = require("./arrayAgg.cjs");
+const require_queries_sql_expressions_codecs = require("./codecs.cjs");
+//#region src/queries/sql/expressions/expression.ts
+/** Builds a reusable SQL value expression, binding literal values as parameters. */
+function expr(input) {
+	return buildExpr(input);
+}
+/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */
+function buildExpr(input) {
+	return new ObjectExpr(require_queries_sql_expressions_parseExpression.parseExpressionInput(input));
+}
+/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */
+var ObjectExpr = class extends require_queries_sql_Expr.BaseExpr {
+	parsed;
+	codec;
+	constructor(parsed) {
+		super();
+		this.parsed = parsed;
+		this.codec = require_queries_sql_expressions_codecs.chooseExpressionCodec(parsed);
+	}
+	get outputType() {
+		return this.codec.outputType;
+	}
+	get sqlNullable() {
+		return expressionNullable(this.parsed);
+	}
+	toSql(ctx) {
+		return expressionToSql(this.parsed, ctx, this.codec);
+	}
+	decode(value) {
+		return value == null ? value : this.codec.decode(value);
+	}
+	encode(value) {
+		return value == null ? value : this.codec.encode(value);
+	}
+};
+/**
+* Reports nullability from the fields of each parsed expression kind.
+* A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.
+*/
+function expressionNullable(parsed) {
+	if (parsed instanceof require_queries_sql_Expr.BaseExpr) return parsed.sqlSource ? void 0 : parsed.sqlNullable;
+	switch (parsed.kind) {
+		case "literal": return parsed.value === null;
+		case "arrayAgg": return true;
+		case "nullIf": return require_queries_sql_expressions_nullIf.nullIfNullable();
+		case "coalesce": return require_queries_sql_expressions_coalesce.coalesceNullable(parsed);
+		case "greatest": return require_queries_sql_expressions_greatest.greatestNullable(parsed);
+		case "least": return require_queries_sql_expressions_least.leastNullable(parsed);
+		case "case": return require_queries_sql_expressions_case.caseNullable(parsed);
+		default: return require_utils.assertNever(parsed);
+	}
+}
+/**
+* Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.
+* An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.
+*/
+function expressionToSql(parsed, ctx, codec) {
+	if (parsed instanceof require_queries_sql_Expr.BaseExpr) return parsed.toSql(ctx);
+	switch (parsed.kind) {
+		case "literal": {
+			const dbType = codec.outputType?.dbType;
+			return {
+				sql: dbType ? `?::${dbType}` : "?",
+				bindings: [parsed.value === null ? null : codec.encode(parsed.value)],
+				refs: []
+			};
+		}
+		case "arrayAgg": return require_queries_sql_expressions_arrayAgg.arrayAggToSql(parsed, ctx, require_queries_sql_expressions_codecs.chooseExpressionCodec(parsed.value));
+		case "coalesce": return require_queries_sql_expressions_coalesce.coalesceToSql(parsed, ctx, codec);
+		case "nullIf": return require_queries_sql_expressions_nullIf.nullIfToSql(parsed, ctx, codec);
+		case "greatest": return require_queries_sql_expressions_greatest.greatestToSql(parsed, ctx, codec);
+		case "least": return require_queries_sql_expressions_least.leastToSql(parsed, ctx, codec);
+		case "case": return require_queries_sql_expressions_case.caseToSql(parsed, ctx, codec);
+		default: return require_utils.assertNever(parsed);
+	}
+}
+/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */
+function functionToSql(name, args, ctx, codec) {
+	const parts = require_queries_sql_Expr.joinFragments(args.map((arg) => expressionToSql(arg, ctx, codec)), ", ");
+	return {
+		...parts,
+		sql: `${name}(${parts.sql})`
+	};
+}
+//#endregion
+exports.buildExpr = buildExpr;
+exports.expr = expr;
+exports.expressionNullable = expressionNullable;
+exports.expressionToSql = expressionToSql;
+exports.functionToSql = functionToSql;
+
+//# sourceMappingURL=expression.cjs.map

package/build/queries/sql/expressions/expression.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.cjs","names":["parseExpressionInput","BaseExpr","chooseExpressionCodec","nullIfNullable","coalesceNullable","greatestNullable","leastNullable","caseNullable","assertNever","arrayAggToSql","coalesceToSql","nullIfToSql","greatestToSql","leastToSql","caseToSql","joinFragments"],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"src/queries/sql/Expr.ts\";\nimport { arrayAggToSql } from \"src/queries/sql/expressions/arrayAgg.ts\";\nimport { caseNullable, caseToSql } from \"src/queries/sql/expressions/case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"src/queries/sql/expressions/coalesce.ts\";\nimport { chooseExpressionCodec } from \"src/queries/sql/expressions/codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"src/queries/sql/expressions/greatest.ts\";\nimport { leastNullable, leastToSql } from \"src/queries/sql/expressions/least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"src/queries/sql/expressions/nullIf.ts\";\nimport { parseExpressionInput } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type {\n  CheckInput,\n  ExprFromInput,\n  ExprInput,\n  ParsedExpression,\n  ResultCodec,\n} from \"src/queries/sql/expressions/types.ts\";\nimport type { TypeInfo } from \"src/serde/TypeInfo.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\nexport type { CaseElse, CaseWhen } from \"src/queries/sql/expressions/case.ts\";\nexport type {\n  CheckInput,\n  ExprFromInput,\n  ExprInput,\n  ExpressionSources,\n  ExpressionValue,\n} from \"src/queries/sql/expressions/types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"arrayAgg\":\n      return true;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"arrayAgg\":\n      return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;;AA6BA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAWA,gDAAAA,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyBC,yBAAAA,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQC,uCAAAA,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkBD,yBAAAA,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,YACH,OAAO;EACT,KAAK,UACH,OAAOE,uCAAAA,eAAe;EACxB,KAAK,YACH,OAAOC,yCAAAA,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAOC,yCAAAA,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAOC,sCAAAA,cAAc,MAAM;EAC7B,KAAK,QACH,OAAOC,qCAAAA,aAAa,MAAM;EAC5B,SACE,OAAOC,cAAAA,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkBP,yBAAAA,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAOQ,yCAAAA,cAAc,QAAQ,KAAKP,uCAAAA,sBAAsB,OAAO,KAAK,CAAC;EACvE,KAAK,YACH,OAAOQ,yCAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAOC,uCAAAA,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAOC,yCAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAOC,sCAAAA,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAOC,qCAAAA,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAON,cAAAA,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQO,yBAAAA,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}

package/build/queries/sql/expressions/expression.d.cts

@@ -0,0 +1,23 @@
+import { CaseElse, CaseWhen } from "./case.cjs";
+import { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue, ParsedExpression, ResultCodec } from "./types.cjs";
+import { BaseExpr, ExprContext, SqlFragment } from "../Expr.cjs";
+//#region src/queries/sql/expressions/expression.d.ts
+/** Builds a reusable SQL value expression, binding literal values as parameters. */
+declare function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I>;
+/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */
+declare function buildExpr(input: unknown): BaseExpr;
+/**
+ * Reports nullability from the fields of each parsed expression kind.
+ * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.
+ */
+declare function expressionNullable(parsed: ParsedExpression): boolean | undefined;
+/**
+ * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.
+ * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.
+ */
+declare function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */
+declare function functionToSql(name: string, args: readonly ParsedExpression[], ctx: ExprContext, codec: ResultCodec): SqlFragment;
+//#endregion
+export { type CaseElse, type CaseWhen, type CheckInput, type ExprFromInput, type ExprInput, type ExpressionSources, type ExpressionValue, buildExpr, expr, expressionNullable, expressionToSql, functionToSql };
+//# sourceMappingURL=expression.d.cts.map

package/build/queries/sql/expressions/expression.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.cts","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"mappings":";;;;;iBA6BgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBA0B3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA6BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}

package/build/queries/sql/expressions/expression.d.mts

@@ -0,0 +1,23 @@
+import { CaseElse, CaseWhen } from "./case.mjs";
+import { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue, ParsedExpression, ResultCodec } from "./types.mjs";
+import { BaseExpr, ExprContext, SqlFragment } from "../Expr.mjs";
+//#region src/queries/sql/expressions/expression.d.ts
+/** Builds a reusable SQL value expression, binding literal values as parameters. */
+declare function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I>;
+/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */
+declare function buildExpr(input: unknown): BaseExpr;
+/**
+ * Reports nullability from the fields of each parsed expression kind.
+ * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.
+ */
+declare function expressionNullable(parsed: ParsedExpression): boolean | undefined;
+/**
+ * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.
+ * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.
+ */
+declare function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */
+declare function functionToSql(name: string, args: readonly ParsedExpression[], ctx: ExprContext, codec: ResultCodec): SqlFragment;
+//#endregion
+export { type CaseElse, type CaseWhen, type CheckInput, type ExprFromInput, type ExprInput, type ExpressionSources, type ExpressionValue, buildExpr, expr, expressionNullable, expressionToSql, functionToSql };
+//# sourceMappingURL=expression.d.mts.map

package/build/queries/sql/expressions/expression.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.d.mts","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"mappings":";;;;;iBA6BgB,WAAW,UAAU,WAAW,OAAO,IAAI,WAAW,QAAQ,MAAM,cAAc;;iBAKlF,UAAU,iBAAiB;;;;;iBAsC3B,mBAAmB,QAAQ;;;;;iBA0B3B,gBAAgB,QAAQ,kBAAkB,KAAK,aAAa,OAAO,cAAc;;iBA6BjF,cACd,cACA,eAAe,oBACf,KAAK,aACL,OAAO,cACN"}

package/build/queries/sql/expressions/expression.js

@@ -0,0 +1,97 @@
+import { BaseExpr, joinFragments } from "../Expr.js";
+import { assertNever } from "../../../utils.js";
+import { caseNullable, caseToSql } from "./case.js";
+import { coalesceNullable, coalesceToSql } from "./coalesce.js";
+import { greatestNullable, greatestToSql } from "./greatest.js";
+import { leastNullable, leastToSql } from "./least.js";
+import { nullIfNullable, nullIfToSql } from "./nullIf.js";
+import { parseExpressionInput } from "./parseExpression.js";
+import { arrayAggToSql } from "./arrayAgg.js";
+import { chooseExpressionCodec } from "./codecs.js";
+//#region src/queries/sql/expressions/expression.ts
+/** Builds a reusable SQL value expression, binding literal values as parameters. */
+function expr(input) {
+	return buildExpr(input);
+}
+/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */
+function buildExpr(input) {
+	return new ObjectExpr(parseExpressionInput(input));
+}
+/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */
+var ObjectExpr = class extends BaseExpr {
+	parsed;
+	codec;
+	constructor(parsed) {
+		super();
+		this.parsed = parsed;
+		this.codec = chooseExpressionCodec(parsed);
+	}
+	get outputType() {
+		return this.codec.outputType;
+	}
+	get sqlNullable() {
+		return expressionNullable(this.parsed);
+	}
+	toSql(ctx) {
+		return expressionToSql(this.parsed, ctx, this.codec);
+	}
+	decode(value) {
+		return value == null ? value : this.codec.decode(value);
+	}
+	encode(value) {
+		return value == null ? value : this.codec.encode(value);
+	}
+};
+/**
+* Reports nullability from the fields of each parsed expression kind.
+* A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.
+*/
+function expressionNullable(parsed) {
+	if (parsed instanceof BaseExpr) return parsed.sqlSource ? void 0 : parsed.sqlNullable;
+	switch (parsed.kind) {
+		case "literal": return parsed.value === null;
+		case "arrayAgg": return true;
+		case "nullIf": return nullIfNullable();
+		case "coalesce": return coalesceNullable(parsed);
+		case "greatest": return greatestNullable(parsed);
+		case "least": return leastNullable(parsed);
+		case "case": return caseNullable(parsed);
+		default: return assertNever(parsed);
+	}
+}
+/**
+* Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.
+* An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.
+*/
+function expressionToSql(parsed, ctx, codec) {
+	if (parsed instanceof BaseExpr) return parsed.toSql(ctx);
+	switch (parsed.kind) {
+		case "literal": {
+			const dbType = codec.outputType?.dbType;
+			return {
+				sql: dbType ? `?::${dbType}` : "?",
+				bindings: [parsed.value === null ? null : codec.encode(parsed.value)],
+				refs: []
+			};
+		}
+		case "arrayAgg": return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));
+		case "coalesce": return coalesceToSql(parsed, ctx, codec);
+		case "nullIf": return nullIfToSql(parsed, ctx, codec);
+		case "greatest": return greatestToSql(parsed, ctx, codec);
+		case "least": return leastToSql(parsed, ctx, codec);
+		case "case": return caseToSql(parsed, ctx, codec);
+		default: return assertNever(parsed);
+	}
+}
+/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */
+function functionToSql(name, args, ctx, codec) {
+	const parts = joinFragments(args.map((arg) => expressionToSql(arg, ctx, codec)), ", ");
+	return {
+		...parts,
+		sql: `${name}(${parts.sql})`
+	};
+}
+//#endregion
+export { buildExpr, expr, expressionNullable, expressionToSql, functionToSql };
+
+//# sourceMappingURL=expression.js.map

package/build/queries/sql/expressions/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.js","names":[],"sources":["../../../../src/queries/sql/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"src/queries/sql/Expr.ts\";\nimport { arrayAggToSql } from \"src/queries/sql/expressions/arrayAgg.ts\";\nimport { caseNullable, caseToSql } from \"src/queries/sql/expressions/case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"src/queries/sql/expressions/coalesce.ts\";\nimport { chooseExpressionCodec } from \"src/queries/sql/expressions/codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"src/queries/sql/expressions/greatest.ts\";\nimport { leastNullable, leastToSql } from \"src/queries/sql/expressions/least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"src/queries/sql/expressions/nullIf.ts\";\nimport { parseExpressionInput } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type {\n  CheckInput,\n  ExprFromInput,\n  ExprInput,\n  ParsedExpression,\n  ResultCodec,\n} from \"src/queries/sql/expressions/types.ts\";\nimport type { TypeInfo } from \"src/serde/TypeInfo.ts\";\nimport { assertNever } from \"src/utils.ts\";\n\nexport type { CaseElse, CaseWhen } from \"src/queries/sql/expressions/case.ts\";\nexport type {\n  CheckInput,\n  ExprFromInput,\n  ExprInput,\n  ExpressionSources,\n  ExpressionValue,\n} from \"src/queries/sql/expressions/types.ts\";\n\n/** Builds a reusable SQL value expression, binding literal values as parameters. */\nexport function expr<const I extends ExprInput>(input: I & CheckInput<NoInfer<I>>): ExprFromInput<I> {\n  return buildExpr(input) as unknown as ExprFromInput<I>;\n}\n\n/** Parses explicit and inline inputs into a ParsedExpression, then wraps it in an Expr with a result codec. */\nexport function buildExpr(input: unknown): BaseExpr {\n  return new ObjectExpr(parseExpressionInput(input));\n}\n\n/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */\nclass ObjectExpr extends BaseExpr {\n  private readonly codec: ResultCodec;\n\n  constructor(private readonly parsed: ParsedExpression) {\n    super();\n    this.codec = chooseExpressionCodec(parsed);\n  }\n\n  get outputType(): TypeInfo | undefined {\n    return this.codec.outputType;\n  }\n\n  get sqlNullable(): boolean | undefined {\n    return expressionNullable(this.parsed);\n  }\n\n  toSql(ctx: ExprContext): SqlFragment {\n    return expressionToSql(this.parsed, ctx, this.codec);\n  }\n\n  decode(value: unknown): unknown {\n    return value == null ? value : this.codec.decode(value);\n  }\n\n  encode(value: unknown): unknown {\n    return value == null ? value : this.codec.encode(value);\n  }\n}\n\n/**\n * Reports nullability from the fields of each parsed expression kind.\n * A direct column can become null through a LEFT join, so only independent values prove NOT NULL here.\n */\nexport function expressionNullable(parsed: ParsedExpression): boolean | undefined {\n  if (parsed instanceof BaseExpr) return parsed.sqlSource ? undefined : parsed.sqlNullable;\n  switch (parsed.kind) {\n    case \"literal\":\n      return parsed.value === null;\n    case \"arrayAgg\":\n      return true;\n    case \"nullIf\":\n      return nullIfNullable();\n    case \"coalesce\":\n      return coalesceNullable(parsed);\n    case \"greatest\":\n      return greatestNullable(parsed);\n    case \"least\":\n      return leastNullable(parsed);\n    case \"case\":\n      return caseNullable(parsed);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/**\n * Renders a ParsedExpression in SQL binding order, resolving CASE conditions and collecting references for join pruning.\n * An omitted CASE condition removes its value as well. I.e. an unused Book.title branch must not keep the Book join.\n */\nexport function expressionToSql(parsed: ParsedExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  if (parsed instanceof BaseExpr) return parsed.toSql(ctx);\n  switch (parsed.kind) {\n    case \"literal\": {\n      const dbType = codec.outputType?.dbType;\n      return {\n        sql: dbType ? `?::${dbType}` : \"?\",\n        bindings: [parsed.value === null ? null : codec.encode(parsed.value)],\n        refs: [],\n      };\n    }\n    case \"arrayAgg\":\n      return arrayAggToSql(parsed, ctx, chooseExpressionCodec(parsed.value));\n    case \"coalesce\":\n      return coalesceToSql(parsed, ctx, codec);\n    case \"nullIf\":\n      return nullIfToSql(parsed, ctx, codec);\n    case \"greatest\":\n      return greatestToSql(parsed, ctx, codec);\n    case \"least\":\n      return leastToSql(parsed, ctx, codec);\n    case \"case\":\n      return caseToSql(parsed, ctx, codec);\n    default:\n      return assertNever(parsed);\n  }\n}\n\n/** Renders a function call after its parsed kind has supplied the arguments in SQL order. */\nexport function functionToSql(\n  name: string,\n  args: readonly ParsedExpression[],\n  ctx: ExprContext,\n  codec: ResultCodec,\n): SqlFragment {\n  const parts = joinFragments(\n    args.map((arg) => expressionToSql(arg, ctx, codec)),\n    \", \",\n  );\n  return { ...parts, sql: `${name}(${parts.sql})` };\n}\n"],"mappings":";;;;;;;;;;;;AA6BA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAW,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyB,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQ,sBAAsB,MAAM;CAC3C;CAEA,IAAI,aAAmC;EACrC,OAAO,KAAK,MAAM;CACpB;CAEA,IAAI,cAAmC;EACrC,OAAO,mBAAmB,KAAK,MAAM;CACvC;CAEA,MAAM,KAA+B;EACnC,OAAO,gBAAgB,KAAK,QAAQ,KAAK,KAAK,KAAK;CACrD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;CAEA,OAAO,OAAyB;EAC9B,OAAO,SAAS,OAAO,QAAQ,KAAK,MAAM,OAAO,KAAK;CACxD;AACF;;;;;AAMA,SAAgB,mBAAmB,QAA+C;CAChF,IAAI,kBAAkB,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,YACH,OAAO;EACT,KAAK,UACH,OAAO,eAAe;EACxB,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAO,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAO,cAAc,MAAM;EAC7B,KAAK,QACH,OAAO,aAAa,MAAM;EAC5B,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkB,UAAU,OAAO,OAAO,MAAM,GAAG;CACvD,QAAQ,OAAO,MAAf;EACE,KAAK,WAAW;GACd,MAAM,SAAS,MAAM,YAAY;GACjC,OAAO;IACL,KAAK,SAAS,MAAM,WAAW;IAC/B,UAAU,CAAC,OAAO,UAAU,OAAO,OAAO,MAAM,OAAO,OAAO,KAAK,CAAC;IACpE,MAAM,CAAC;GACT;EACF;EACA,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,sBAAsB,OAAO,KAAK,CAAC;EACvE,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAO,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAO,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAO,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAO,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAO,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQ,cACZ,KAAK,KAAK,QAAQ,gBAAgB,KAAK,KAAK,KAAK,CAAC,GAClD,IACF;CACA,OAAO;EAAE,GAAG;EAAO,KAAK,GAAG,KAAK,GAAG,MAAM,IAAI;CAAG;AAClD"}

package/build/queries/sql/expressions/greatest.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_queries_sql_expressions_parseExpression = require("./parseExpression.cjs");
+const require_queries_sql_expressions_expression = require("./expression.cjs");
+//#region src/queries/sql/expressions/greatest.ts
+/** Parses GREATEST values and requires at least one operand. */
+function parseGreatestExpression(input) {
+	return {
+		kind: "greatest",
+		values: require_queries_sql_expressions_parseExpression.parseNonEmptyOperands(input, "GREATEST")
+	};
+}
+/** Renders the values compared by GREATEST. */
+function greatestToSql(parsed, ctx, codec) {
+	return require_queries_sql_expressions_expression.functionToSql("GREATEST", parsed.values, ctx, codec);
+}
+/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */
+function greatestNullable(parsed) {
+	return parsed.values.some((value) => require_queries_sql_expressions_expression.expressionNullable(value) === false) ? false : void 0;
+}
+//#endregion
+exports.greatestNullable = greatestNullable;
+exports.greatestToSql = greatestToSql;
+exports.parseGreatestExpression = parseGreatestExpression;
+
+//# sourceMappingURL=greatest.cjs.map

package/build/queries/sql/expressions/greatest.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"greatest.cjs","names":["parseNonEmptyOperands","functionToSql","expressionNullable"],"sources":["../../../../src/queries/sql/expressions/greatest.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseNonEmptyOperands } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** Values whose largest non-null member is selected by PostgreSQL. */\nexport interface GreatestInput {\n  readonly greatest: readonly unknown[];\n}\n\n/** A GREATEST comparison with at least one value. */\nexport interface ParsedGreatestExpression {\n  kind: \"greatest\";\n  values: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses GREATEST values and requires at least one operand. */\nexport function parseGreatestExpression(input: unknown): ParsedGreatestExpression {\n  return { kind: \"greatest\", values: parseNonEmptyOperands(input, \"GREATEST\") };\n}\n\n/** Renders the values compared by GREATEST. */\nexport function greatestToSql(parsed: ParsedGreatestExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"GREATEST\", parsed.values, ctx, codec);\n}\n\n/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */\nexport function greatestNullable(parsed: ParsedGreatestExpression): boolean | undefined {\n  return parsed.values.some((value) => expressionNullable(value) === false) ? false : undefined;\n}\n"],"mappings":";;;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,QAAQA,gDAAAA,sBAAsB,OAAO,UAAU;CAAE;AAC9E;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAOC,2CAAAA,cAAc,YAAY,OAAO,QAAQ,KAAK,KAAK;AAC5D;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,OAAO,MAAM,UAAUC,2CAAAA,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}

package/build/queries/sql/expressions/greatest.d.cts

@@ -0,0 +1,21 @@
+import { ParsedExpression, ResultCodec } from "./types.cjs";
+import { ExprContext, SqlFragment } from "../Expr.cjs";
+//#region src/queries/sql/expressions/greatest.d.ts
+/** Values whose largest non-null member is selected by PostgreSQL. */
+interface GreatestInput {
+  readonly greatest: readonly unknown[];
+}
+/** A GREATEST comparison with at least one value. */
+interface ParsedGreatestExpression {
+  kind: "greatest";
+  values: [ParsedExpression, ...ParsedExpression[]];
+}
+/** Parses GREATEST values and requires at least one operand. */
+declare function parseGreatestExpression(input: unknown): ParsedGreatestExpression;
+/** Renders the values compared by GREATEST. */
+declare function greatestToSql(parsed: ParsedGreatestExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */
+declare function greatestNullable(parsed: ParsedGreatestExpression): boolean | undefined;
+//#endregion
+export { GreatestInput, ParsedGreatestExpression, greatestNullable, greatestToSql, parseGreatestExpression };
+//# sourceMappingURL=greatest.d.cts.map

package/build/queries/sql/expressions/greatest.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greatest.d.cts","names":[],"sources":["../../../../src/queries/sql/expressions/greatest.ts"],"mappings":";;;;UAMiB;WACN;;;UAIM;EACf;EACA,SAAS,qBAAqB;;;iBAIhB,wBAAwB,iBAAiB;;iBAKzC,cAAc,QAAQ,0BAA0B,KAAK,aAAa,OAAO,cAAc;;iBAKvF,iBAAiB,QAAQ"}

package/build/queries/sql/expressions/greatest.d.mts

@@ -0,0 +1,21 @@
+import { ParsedExpression, ResultCodec } from "./types.mjs";
+import { ExprContext, SqlFragment } from "../Expr.mjs";
+//#region src/queries/sql/expressions/greatest.d.ts
+/** Values whose largest non-null member is selected by PostgreSQL. */
+interface GreatestInput {
+  readonly greatest: readonly unknown[];
+}
+/** A GREATEST comparison with at least one value. */
+interface ParsedGreatestExpression {
+  kind: "greatest";
+  values: [ParsedExpression, ...ParsedExpression[]];
+}
+/** Parses GREATEST values and requires at least one operand. */
+declare function parseGreatestExpression(input: unknown): ParsedGreatestExpression;
+/** Renders the values compared by GREATEST. */
+declare function greatestToSql(parsed: ParsedGreatestExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */
+declare function greatestNullable(parsed: ParsedGreatestExpression): boolean | undefined;
+//#endregion
+export { GreatestInput, ParsedGreatestExpression, greatestNullable, greatestToSql, parseGreatestExpression };
+//# sourceMappingURL=greatest.d.mts.map

package/build/queries/sql/expressions/greatest.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greatest.d.mts","names":[],"sources":["../../../../src/queries/sql/expressions/greatest.ts"],"mappings":";;;;UAMiB;WACN;;;UAIM;EACf;EACA,SAAS,qBAAqB;;;iBAIhB,wBAAwB,iBAAiB;;iBAKzC,cAAc,QAAQ,0BAA0B,KAAK,aAAa,OAAO,cAAc;;iBAKvF,iBAAiB,QAAQ"}

package/build/queries/sql/expressions/greatest.js

@@ -0,0 +1,22 @@
+import { parseNonEmptyOperands } from "./parseExpression.js";
+import { expressionNullable, functionToSql } from "./expression.js";
+//#region src/queries/sql/expressions/greatest.ts
+/** Parses GREATEST values and requires at least one operand. */
+function parseGreatestExpression(input) {
+	return {
+		kind: "greatest",
+		values: parseNonEmptyOperands(input, "GREATEST")
+	};
+}
+/** Renders the values compared by GREATEST. */
+function greatestToSql(parsed, ctx, codec) {
+	return functionToSql("GREATEST", parsed.values, ctx, codec);
+}
+/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */
+function greatestNullable(parsed) {
+	return parsed.values.some((value) => expressionNullable(value) === false) ? false : void 0;
+}
+//#endregion
+export { greatestNullable, greatestToSql, parseGreatestExpression };
+
+//# sourceMappingURL=greatest.js.map

package/build/queries/sql/expressions/greatest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greatest.js","names":[],"sources":["../../../../src/queries/sql/expressions/greatest.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseNonEmptyOperands } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** Values whose largest non-null member is selected by PostgreSQL. */\nexport interface GreatestInput {\n  readonly greatest: readonly unknown[];\n}\n\n/** A GREATEST comparison with at least one value. */\nexport interface ParsedGreatestExpression {\n  kind: \"greatest\";\n  values: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses GREATEST values and requires at least one operand. */\nexport function parseGreatestExpression(input: unknown): ParsedGreatestExpression {\n  return { kind: \"greatest\", values: parseNonEmptyOperands(input, \"GREATEST\") };\n}\n\n/** Renders the values compared by GREATEST. */\nexport function greatestToSql(parsed: ParsedGreatestExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"GREATEST\", parsed.values, ctx, codec);\n}\n\n/** GREATEST ignores nulls, so one non-null value guarantees a non-null result. */\nexport function greatestNullable(parsed: ParsedGreatestExpression): boolean | undefined {\n  return parsed.values.some((value) => expressionNullable(value) === false) ? false : undefined;\n}\n"],"mappings":";;;;AAiBA,SAAgB,wBAAwB,OAA0C;CAChF,OAAO;EAAE,MAAM;EAAY,QAAQ,sBAAsB,OAAO,UAAU;CAAE;AAC9E;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAO,cAAc,YAAY,OAAO,QAAQ,KAAK,KAAK;AAC5D;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,OAAO,MAAM,UAAU,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}

package/build/queries/sql/expressions/least.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_queries_sql_expressions_parseExpression = require("./parseExpression.cjs");
+const require_queries_sql_expressions_expression = require("./expression.cjs");
+//#region src/queries/sql/expressions/least.ts
+/** Parses LEAST values and requires at least one operand. */
+function parseLeastExpression(input) {
+	return {
+		kind: "least",
+		values: require_queries_sql_expressions_parseExpression.parseNonEmptyOperands(input, "LEAST")
+	};
+}
+/** Renders the values compared by LEAST. */
+function leastToSql(parsed, ctx, codec) {
+	return require_queries_sql_expressions_expression.functionToSql("LEAST", parsed.values, ctx, codec);
+}
+/** LEAST ignores nulls, so one non-null value guarantees a non-null result. */
+function leastNullable(parsed) {
+	return parsed.values.some((value) => require_queries_sql_expressions_expression.expressionNullable(value) === false) ? false : void 0;
+}
+//#endregion
+exports.leastNullable = leastNullable;
+exports.leastToSql = leastToSql;
+exports.parseLeastExpression = parseLeastExpression;
+
+//# sourceMappingURL=least.cjs.map

package/build/queries/sql/expressions/least.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"least.cjs","names":["parseNonEmptyOperands","functionToSql","expressionNullable"],"sources":["../../../../src/queries/sql/expressions/least.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"src/queries/sql/Expr.ts\";\nimport { expressionNullable, functionToSql } from \"src/queries/sql/expressions/expression.ts\";\nimport { parseNonEmptyOperands } from \"src/queries/sql/expressions/parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"src/queries/sql/expressions/types.ts\";\n\n/** Values whose smallest non-null member is selected by PostgreSQL. */\nexport interface LeastInput {\n  readonly least: readonly unknown[];\n}\n\n/** A LEAST comparison with at least one value. */\nexport interface ParsedLeastExpression {\n  kind: \"least\";\n  values: [ParsedExpression, ...ParsedExpression[]];\n}\n\n/** Parses LEAST values and requires at least one operand. */\nexport function parseLeastExpression(input: unknown): ParsedLeastExpression {\n  return { kind: \"least\", values: parseNonEmptyOperands(input, \"LEAST\") };\n}\n\n/** Renders the values compared by LEAST. */\nexport function leastToSql(parsed: ParsedLeastExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"LEAST\", parsed.values, ctx, codec);\n}\n\n/** LEAST ignores nulls, so one non-null value guarantees a non-null result. */\nexport function leastNullable(parsed: ParsedLeastExpression): boolean | undefined {\n  return parsed.values.some((value) => expressionNullable(value) === false) ? false : undefined;\n}\n"],"mappings":";;;;;AAiBA,SAAgB,qBAAqB,OAAuC;CAC1E,OAAO;EAAE,MAAM;EAAS,QAAQA,gDAAAA,sBAAsB,OAAO,OAAO;CAAE;AACxE;;AAGA,SAAgB,WAAW,QAA+B,KAAkB,OAAiC;CAC3G,OAAOC,2CAAAA,cAAc,SAAS,OAAO,QAAQ,KAAK,KAAK;AACzD;;AAGA,SAAgB,cAAc,QAAoD;CAChF,OAAO,OAAO,OAAO,MAAM,UAAUC,2CAAAA,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}

package/build/queries/sql/expressions/least.d.cts

@@ -0,0 +1,21 @@
+import { ParsedExpression, ResultCodec } from "./types.cjs";
+import { ExprContext, SqlFragment } from "../Expr.cjs";
+//#region src/queries/sql/expressions/least.d.ts
+/** Values whose smallest non-null member is selected by PostgreSQL. */
+interface LeastInput {
+  readonly least: readonly unknown[];
+}
+/** A LEAST comparison with at least one value. */
+interface ParsedLeastExpression {
+  kind: "least";
+  values: [ParsedExpression, ...ParsedExpression[]];
+}
+/** Parses LEAST values and requires at least one operand. */
+declare function parseLeastExpression(input: unknown): ParsedLeastExpression;
+/** Renders the values compared by LEAST. */
+declare function leastToSql(parsed: ParsedLeastExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** LEAST ignores nulls, so one non-null value guarantees a non-null result. */
+declare function leastNullable(parsed: ParsedLeastExpression): boolean | undefined;
+//#endregion
+export { LeastInput, ParsedLeastExpression, leastNullable, leastToSql, parseLeastExpression };
+//# sourceMappingURL=least.d.cts.map

package/build/queries/sql/expressions/least.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"least.d.cts","names":[],"sources":["../../../../src/queries/sql/expressions/least.ts"],"mappings":";;;;UAMiB;WACN;;;UAIM;EACf;EACA,SAAS,qBAAqB;;;iBAIhB,qBAAqB,iBAAiB;;iBAKtC,WAAW,QAAQ,uBAAuB,KAAK,aAAa,OAAO,cAAc;;iBAKjF,cAAc,QAAQ"}