joist-core 2.3.0-next.87 → 2.3.0-next.89

package/build/expressions/expression.cjs

@@ -0,0 +1,99 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils = require("../utils.cjs");
+const require_Expr = require("../Expr.cjs");
+const require_expressions_coalesce = require("./coalesce.cjs");
+const require_expressions_greatest = require("./greatest.cjs");
+const require_expressions_least = require("./least.cjs");
+const require_expressions_nullIf = require("./nullIf.cjs");
+const require_expressions_parseExpression = require("./parseExpression.cjs");
+const require_expressions_case = require("./case.cjs");
+const require_expressions_codecs = require("./codecs.cjs");
+//#region src/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_expressions_parseExpression.parseExpressionInput(input));
+}
+/** Exposes a ParsedExpression through the Expr methods, SQL rendering, and shared result codec. */
+var ObjectExpr = class extends require_Expr.BaseExpr {
+	parsed;
+	codec;
+	constructor(parsed) {
+		super();
+		this.parsed = parsed;
+		this.codec = require_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_Expr.BaseExpr) return parsed.sqlSource ? void 0 : parsed.sqlNullable;
+	switch (parsed.kind) {
+		case "literal": return parsed.value === null;
+		case "nullIf": return require_expressions_nullIf.nullIfNullable();
+		case "coalesce": return require_expressions_coalesce.coalesceNullable(parsed);
+		case "greatest": return require_expressions_greatest.greatestNullable(parsed);
+		case "least": return require_expressions_least.leastNullable(parsed);
+		case "case": return require_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_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 "coalesce": return require_expressions_coalesce.coalesceToSql(parsed, ctx, codec);
+		case "nullIf": return require_expressions_nullIf.nullIfToSql(parsed, ctx, codec);
+		case "greatest": return require_expressions_greatest.greatestToSql(parsed, ctx, codec);
+		case "least": return require_expressions_least.leastToSql(parsed, ctx, codec);
+		case "case": return require_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_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/expressions/expression.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.cjs","names":["parseExpressionInput","BaseExpr","chooseExpressionCodec","nullIfNullable","coalesceNullable","greatestNullable","leastNullable","caseNullable","assertNever","coalesceToSql","nullIfToSql","greatestToSql","leastToSql","caseToSql","joinFragments"],"sources":["../../src/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport type { TypeInfo } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { caseNullable, caseToSql } from \"./case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"./coalesce.ts\";\nimport { chooseExpressionCodec } from \"./codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"./greatest.ts\";\nimport { leastNullable, leastToSql } from \"./least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"./nullIf.ts\";\nimport { parseExpressionInput } from \"./parseExpression.ts\";\nimport type { CheckInput, ExprFromInput, ExprInput, ParsedExpression, ResultCodec } from \"./types.ts\";\n\nexport type { CaseElse, CaseWhen } from \"./case.ts\";\nexport type { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from \"./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 \"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 \"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":";;;;;;;;;;;;AAgBA,SAAgB,KAAgC,OAAqD;CACnG,OAAO,UAAU,KAAK;AACxB;;AAGA,SAAgB,UAAU,OAA0B;CAClD,OAAO,IAAI,WAAWA,oCAAAA,qBAAqB,KAAK,CAAC;AACnD;;AAGA,IAAM,aAAN,cAAyBC,aAAAA,SAAS;CAGH;CAF7B;CAEA,YAAY,QAA2C;EACrD,MAAM;EADqB,KAAA,SAAA;EAE3B,KAAK,QAAQC,2BAAAA,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,aAAAA,UAAU,OAAO,OAAO,YAAY,KAAA,IAAY,OAAO;CAC7E,QAAQ,OAAO,MAAf;EACE,KAAK,WACH,OAAO,OAAO,UAAU;EAC1B,KAAK,UACH,OAAOE,2BAAAA,eAAe;EACxB,KAAK,YACH,OAAOC,6BAAAA,iBAAiB,MAAM;EAChC,KAAK,YACH,OAAOC,6BAAAA,iBAAiB,MAAM;EAChC,KAAK,SACH,OAAOC,0BAAAA,cAAc,MAAM;EAC7B,KAAK,QACH,OAAOC,yBAAAA,aAAa,MAAM;EAC5B,SACE,OAAOC,cAAAA,YAAY,MAAM;CAC7B;AACF;;;;;AAMA,SAAgB,gBAAgB,QAA0B,KAAkB,OAAiC;CAC3G,IAAI,kBAAkBP,aAAAA,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,6BAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,UACH,OAAOC,2BAAAA,YAAY,QAAQ,KAAK,KAAK;EACvC,KAAK,YACH,OAAOC,6BAAAA,cAAc,QAAQ,KAAK,KAAK;EACzC,KAAK,SACH,OAAOC,0BAAAA,WAAW,QAAQ,KAAK,KAAK;EACtC,KAAK,QACH,OAAOC,yBAAAA,UAAU,QAAQ,KAAK,KAAK;EACrC,SACE,OAAOL,cAAAA,YAAY,MAAM;CAC7B;AACF;;AAGA,SAAgB,cACd,MACA,MACA,KACA,OACa;CACb,MAAM,QAAQM,aAAAA,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/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/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/expressions/expression.d.cts.map

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

package/build/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/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/expressions/expression.d.mts.map

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

package/build/expressions/expression.js

@@ -0,0 +1,94 @@
+import { assertNever } from "../utils.js";
+import { BaseExpr, joinFragments } from "../Expr.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 { caseNullable, caseToSql } from "./case.js";
+import { chooseExpressionCodec } from "./codecs.js";
+//#region src/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 "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 "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/expressions/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression.js","names":[],"sources":["../../src/expressions/expression.ts"],"sourcesContent":["import { BaseExpr, type ExprContext, type SqlFragment, joinFragments } from \"../Expr.ts\";\nimport type { TypeInfo } from \"../TypeInfo.ts\";\nimport { assertNever } from \"../utils.ts\";\nimport { caseNullable, caseToSql } from \"./case.ts\";\nimport { coalesceNullable, coalesceToSql } from \"./coalesce.ts\";\nimport { chooseExpressionCodec } from \"./codecs.ts\";\nimport { greatestNullable, greatestToSql } from \"./greatest.ts\";\nimport { leastNullable, leastToSql } from \"./least.ts\";\nimport { nullIfNullable, nullIfToSql } from \"./nullIf.ts\";\nimport { parseExpressionInput } from \"./parseExpression.ts\";\nimport type { CheckInput, ExprFromInput, ExprInput, ParsedExpression, ResultCodec } from \"./types.ts\";\n\nexport type { CaseElse, CaseWhen } from \"./case.ts\";\nexport type { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from \"./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 \"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 \"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":";;;;;;;;;;;AAgBA,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,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,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/expressions/greatest.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_expressions_parseExpression = require("./parseExpression.cjs");
+const require_expressions_expression = require("./expression.cjs");
+//#region src/expressions/greatest.ts
+/** Parses GREATEST values and requires at least one operand. */
+function parseGreatestExpression(input) {
+	return {
+		kind: "greatest",
+		values: require_expressions_parseExpression.parseNonEmptyOperands(input, "GREATEST")
+	};
+}
+/** Renders the values compared by GREATEST. */
+function greatestToSql(parsed, ctx, codec) {
+	return require_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_expressions_expression.expressionNullable(value) === false) ? false : void 0;
+}
+//#endregion
+exports.greatestNullable = greatestNullable;
+exports.greatestToSql = greatestToSql;
+exports.parseGreatestExpression = parseGreatestExpression;
+
+//# sourceMappingURL=greatest.cjs.map

package/build/expressions/greatest.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"greatest.cjs","names":["parseNonEmptyOperands","functionToSql","expressionNullable"],"sources":["../../src/expressions/greatest.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { expressionNullable, functionToSql } from \"./expression.ts\";\nimport { parseNonEmptyOperands } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./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,oCAAAA,sBAAsB,OAAO,UAAU;CAAE;AAC9E;;AAGA,SAAgB,cAAc,QAAkC,KAAkB,OAAiC;CACjH,OAAOC,+BAAAA,cAAc,YAAY,OAAO,QAAQ,KAAK,KAAK;AAC5D;;AAGA,SAAgB,iBAAiB,QAAuD;CACtF,OAAO,OAAO,OAAO,MAAM,UAAUC,+BAAAA,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}

package/build/expressions/greatest.d.cts

@@ -0,0 +1,21 @@
+import { ParsedExpression, ResultCodec } from "./types.cjs";
+import { ExprContext, SqlFragment } from "../Expr.cjs";
+//#region src/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/expressions/greatest.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greatest.d.cts","names":[],"sources":["../../src/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/expressions/greatest.d.mts

@@ -0,0 +1,21 @@
+import { ParsedExpression, ResultCodec } from "./types.mjs";
+import { ExprContext, SqlFragment } from "../Expr.mjs";
+//#region src/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/expressions/greatest.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"greatest.d.mts","names":[],"sources":["../../src/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/expressions/greatest.js

@@ -0,0 +1,22 @@
+import { parseNonEmptyOperands } from "./parseExpression.js";
+import { expressionNullable, functionToSql } from "./expression.js";
+//#region src/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/expressions/greatest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"greatest.js","names":[],"sources":["../../src/expressions/greatest.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { expressionNullable, functionToSql } from \"./expression.ts\";\nimport { parseNonEmptyOperands } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./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/expressions/least.cjs

@@ -0,0 +1,25 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_expressions_parseExpression = require("./parseExpression.cjs");
+const require_expressions_expression = require("./expression.cjs");
+//#region src/expressions/least.ts
+/** Parses LEAST values and requires at least one operand. */
+function parseLeastExpression(input) {
+	return {
+		kind: "least",
+		values: require_expressions_parseExpression.parseNonEmptyOperands(input, "LEAST")
+	};
+}
+/** Renders the values compared by LEAST. */
+function leastToSql(parsed, ctx, codec) {
+	return require_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_expressions_expression.expressionNullable(value) === false) ? false : void 0;
+}
+//#endregion
+exports.leastNullable = leastNullable;
+exports.leastToSql = leastToSql;
+exports.parseLeastExpression = parseLeastExpression;
+
+//# sourceMappingURL=least.cjs.map

package/build/expressions/least.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"least.cjs","names":["parseNonEmptyOperands","functionToSql","expressionNullable"],"sources":["../../src/expressions/least.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { expressionNullable, functionToSql } from \"./expression.ts\";\nimport { parseNonEmptyOperands } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./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,oCAAAA,sBAAsB,OAAO,OAAO;CAAE;AACxE;;AAGA,SAAgB,WAAW,QAA+B,KAAkB,OAAiC;CAC3G,OAAOC,+BAAAA,cAAc,SAAS,OAAO,QAAQ,KAAK,KAAK;AACzD;;AAGA,SAAgB,cAAc,QAAoD;CAChF,OAAO,OAAO,OAAO,MAAM,UAAUC,+BAAAA,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}

package/build/expressions/least.d.cts

@@ -0,0 +1,21 @@
+import { ParsedExpression, ResultCodec } from "./types.cjs";
+import { ExprContext, SqlFragment } from "../Expr.cjs";
+//#region src/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/expressions/least.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"least.d.cts","names":[],"sources":["../../src/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"}

package/build/expressions/least.d.mts

@@ -0,0 +1,21 @@
+import { ParsedExpression, ResultCodec } from "./types.mjs";
+import { ExprContext, SqlFragment } from "../Expr.mjs";
+//#region src/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.mts.map

package/build/expressions/least.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"least.d.mts","names":[],"sources":["../../src/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"}

package/build/expressions/least.js

@@ -0,0 +1,22 @@
+import { parseNonEmptyOperands } from "./parseExpression.js";
+import { expressionNullable, functionToSql } from "./expression.js";
+//#region src/expressions/least.ts
+/** Parses LEAST values and requires at least one operand. */
+function parseLeastExpression(input) {
+	return {
+		kind: "least",
+		values: parseNonEmptyOperands(input, "LEAST")
+	};
+}
+/** Renders the values compared by LEAST. */
+function leastToSql(parsed, ctx, codec) {
+	return 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) => expressionNullable(value) === false) ? false : void 0;
+}
+//#endregion
+export { leastNullable, leastToSql, parseLeastExpression };
+
+//# sourceMappingURL=least.js.map

package/build/expressions/least.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"least.js","names":[],"sources":["../../src/expressions/least.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { expressionNullable, functionToSql } from \"./expression.ts\";\nimport { parseNonEmptyOperands } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./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,QAAQ,sBAAsB,OAAO,OAAO;CAAE;AACxE;;AAGA,SAAgB,WAAW,QAA+B,KAAkB,OAAiC;CAC3G,OAAO,cAAc,SAAS,OAAO,QAAQ,KAAK,KAAK;AACzD;;AAGA,SAAgB,cAAc,QAAoD;CAChF,OAAO,OAAO,OAAO,MAAM,UAAU,mBAAmB,KAAK,MAAM,KAAK,IAAI,QAAQ,KAAA;AACtF"}

package/build/expressions/nullIf.cjs

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_expressions_parseExpression = require("./parseExpression.cjs");
+const require_expressions_expression = require("./expression.cjs");
+//#region src/expressions/nullIf.ts
+/** Parses exactly two NULLIF operands into their distinct roles. */
+function parseNullIfExpression(input) {
+	if (!Array.isArray(input) || input.length !== 2) throw new Error("NULLIF needs exactly two values");
+	return {
+		kind: "nullIf",
+		value: require_expressions_parseExpression.parseExpression(input[0]),
+		equals: require_expressions_parseExpression.parseExpression(input[1])
+	};
+}
+/** Renders the returned value before its equality comparison operand. */
+function nullIfToSql(parsed, ctx, codec) {
+	return require_expressions_expression.functionToSql("NULLIF", [parsed.value, parsed.equals], ctx, codec);
+}
+/** NULLIF can return SQL NULL when its operands match. */
+function nullIfNullable() {
+	return true;
+}
+//#endregion
+exports.nullIfNullable = nullIfNullable;
+exports.nullIfToSql = nullIfToSql;
+exports.parseNullIfExpression = parseNullIfExpression;
+
+//# sourceMappingURL=nullIf.cjs.map

package/build/expressions/nullIf.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullIf.cjs","names":["parseExpression","functionToSql"],"sources":["../../src/expressions/nullIf.ts"],"sourcesContent":["import type { ExprContext, SqlFragment } from \"../Expr.ts\";\nimport { functionToSql } from \"./expression.ts\";\nimport { parseExpression } from \"./parseExpression.ts\";\nimport type { ParsedExpression, ResultCodec } from \"./types.ts\";\n\n/** A value and the value it must equal for NULLIF to return SQL NULL. */\nexport interface NullIfInput {\n  readonly nullIf: readonly unknown[];\n}\n\n/** NULLIF returns value unless it matches equals. */\nexport interface ParsedNullIfExpression {\n  kind: \"nullIf\";\n  value: ParsedExpression;\n  equals: ParsedExpression;\n}\n\n/** Parses exactly two NULLIF operands into their distinct roles. */\nexport function parseNullIfExpression(input: unknown): ParsedNullIfExpression {\n  if (!Array.isArray(input) || input.length !== 2) throw new Error(\"NULLIF needs exactly two values\");\n  return { kind: \"nullIf\", value: parseExpression(input[0]), equals: parseExpression(input[1]) };\n}\n\n/** Renders the returned value before its equality comparison operand. */\nexport function nullIfToSql(parsed: ParsedNullIfExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment {\n  return functionToSql(\"NULLIF\", [parsed.value, parsed.equals], ctx, codec);\n}\n\n/** NULLIF can return SQL NULL when its operands match. */\nexport function nullIfNullable(): true {\n  return true;\n}\n"],"mappings":";;;;;AAkBA,SAAgB,sBAAsB,OAAwC;CAC5E,IAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,MAAM,WAAW,GAAG,MAAM,IAAI,MAAM,iCAAiC;CAClG,OAAO;EAAE,MAAM;EAAU,OAAOA,oCAAAA,gBAAgB,MAAM,EAAE;EAAG,QAAQA,oCAAAA,gBAAgB,MAAM,EAAE;CAAE;AAC/F;;AAGA,SAAgB,YAAY,QAAgC,KAAkB,OAAiC;CAC7G,OAAOC,+BAAAA,cAAc,UAAU,CAAC,OAAO,OAAO,OAAO,MAAM,GAAG,KAAK,KAAK;AAC1E;;AAGA,SAAgB,iBAAuB;CACrC,OAAO;AACT"}

package/build/expressions/nullIf.d.cts

@@ -0,0 +1,22 @@
+import { ParsedExpression, ResultCodec } from "./types.cjs";
+import { ExprContext, SqlFragment } from "../Expr.cjs";
+//#region src/expressions/nullIf.d.ts
+/** A value and the value it must equal for NULLIF to return SQL NULL. */
+interface NullIfInput {
+  readonly nullIf: readonly unknown[];
+}
+/** NULLIF returns value unless it matches equals. */
+interface ParsedNullIfExpression {
+  kind: "nullIf";
+  value: ParsedExpression;
+  equals: ParsedExpression;
+}
+/** Parses exactly two NULLIF operands into their distinct roles. */
+declare function parseNullIfExpression(input: unknown): ParsedNullIfExpression;
+/** Renders the returned value before its equality comparison operand. */
+declare function nullIfToSql(parsed: ParsedNullIfExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** NULLIF can return SQL NULL when its operands match. */
+declare function nullIfNullable(): true;
+//#endregion
+export { NullIfInput, ParsedNullIfExpression, nullIfNullable, nullIfToSql, parseNullIfExpression };
+//# sourceMappingURL=nullIf.d.cts.map

package/build/expressions/nullIf.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullIf.d.cts","names":[],"sources":["../../src/expressions/nullIf.ts"],"mappings":";;;;UAMiB;WACN;;;UAIM;EACf;EACA,OAAO;EACP,QAAQ;;;iBAIM,sBAAsB,iBAAiB;;iBAMvC,YAAY,QAAQ,wBAAwB,KAAK,aAAa,OAAO,cAAc;;iBAKnF"}

package/build/expressions/nullIf.d.mts

@@ -0,0 +1,22 @@
+import { ParsedExpression, ResultCodec } from "./types.mjs";
+import { ExprContext, SqlFragment } from "../Expr.mjs";
+//#region src/expressions/nullIf.d.ts
+/** A value and the value it must equal for NULLIF to return SQL NULL. */
+interface NullIfInput {
+  readonly nullIf: readonly unknown[];
+}
+/** NULLIF returns value unless it matches equals. */
+interface ParsedNullIfExpression {
+  kind: "nullIf";
+  value: ParsedExpression;
+  equals: ParsedExpression;
+}
+/** Parses exactly two NULLIF operands into their distinct roles. */
+declare function parseNullIfExpression(input: unknown): ParsedNullIfExpression;
+/** Renders the returned value before its equality comparison operand. */
+declare function nullIfToSql(parsed: ParsedNullIfExpression, ctx: ExprContext, codec: ResultCodec): SqlFragment;
+/** NULLIF can return SQL NULL when its operands match. */
+declare function nullIfNullable(): true;
+//#endregion
+export { NullIfInput, ParsedNullIfExpression, nullIfNullable, nullIfToSql, parseNullIfExpression };
+//# sourceMappingURL=nullIf.d.mts.map

package/build/expressions/nullIf.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nullIf.d.mts","names":[],"sources":["../../src/expressions/nullIf.ts"],"mappings":";;;;UAMiB;WACN;;;UAIM;EACf;EACA,OAAO;EACP,QAAQ;;;iBAIM,sBAAsB,iBAAiB;;iBAMvC,YAAY,QAAQ,wBAAwB,KAAK,aAAa,OAAO,cAAc;;iBAKnF"}

package/build/expressions/nullIf.js

@@ -0,0 +1,24 @@
+import { parseExpression } from "./parseExpression.js";
+import { functionToSql } from "./expression.js";
+//#region src/expressions/nullIf.ts
+/** Parses exactly two NULLIF operands into their distinct roles. */
+function parseNullIfExpression(input) {
+	if (!Array.isArray(input) || input.length !== 2) throw new Error("NULLIF needs exactly two values");
+	return {
+		kind: "nullIf",
+		value: parseExpression(input[0]),
+		equals: parseExpression(input[1])
+	};
+}
+/** Renders the returned value before its equality comparison operand. */
+function nullIfToSql(parsed, ctx, codec) {
+	return functionToSql("NULLIF", [parsed.value, parsed.equals], ctx, codec);
+}
+/** NULLIF can return SQL NULL when its operands match. */
+function nullIfNullable() {
+	return true;
+}
+//#endregion
+export { nullIfNullable, nullIfToSql, parseNullIfExpression };
+
+//# sourceMappingURL=nullIf.js.map