@prisma-next/sql-relational-core 0.3.0-pr.99.6 → 0.4.0-dev.1

package/dist/exports/ast.mjs

@@ -0,0 +1,1358 @@
+import { ifDefined } from "@prisma-next/utils/defined";
+import { type } from "arktype";
+
+//#region src/ast/codec-types.ts
+/**
+* Implementation of CodecRegistry.
+*/
+var CodecRegistryImpl = class {
+	_byId = /* @__PURE__ */ new Map();
+	_byScalar = /* @__PURE__ */ new Map();
+	/**
+	* Map-like interface for codec lookup by ID.
+	* Example: registry.get('pg/text@1')
+	*/
+	get(id) {
+		return this._byId.get(id);
+	}
+	/**
+	* Check if a codec with the given ID is registered.
+	*/
+	has(id) {
+		return this._byId.has(id);
+	}
+	/**
+	* Get all codecs that handle a given scalar type.
+	* Returns an empty frozen array if no codecs are found.
+	* Example: registry.getByScalar('text') → [codec1, codec2, ...]
+	*/
+	getByScalar(scalar) {
+		return this._byScalar.get(scalar) ?? Object.freeze([]);
+	}
+	/**
+	* Get the default codec for a scalar type (first registered codec).
+	* Returns undefined if no codec handles this scalar type.
+	*/
+	getDefaultCodec(scalar) {
+		return this._byScalar.get(scalar)?.[0];
+	}
+	/**
+	* Register a codec in the registry.
+	* Throws an error if a codec with the same ID is already registered.
+	*
+	* @param codec - The codec to register
+	* @throws Error if a codec with the same ID already exists
+	*/
+	register(codec$1) {
+		if (this._byId.has(codec$1.id)) throw new Error(`Codec with ID '${codec$1.id}' is already registered`);
+		this._byId.set(codec$1.id, codec$1);
+		for (const scalarType of codec$1.targetTypes) {
+			const existing = this._byScalar.get(scalarType);
+			if (existing) existing.push(codec$1);
+			else this._byScalar.set(scalarType, [codec$1]);
+		}
+	}
+	hasTrait(codecId, trait) {
+		return this._byId.get(codecId)?.traits?.includes(trait) ?? false;
+	}
+	traitsOf(codecId) {
+		return this._byId.get(codecId)?.traits ?? [];
+	}
+	/**
+	* Returns an iterator over all registered codecs.
+	* Useful for iterating through codecs from another registry.
+	*/
+	*[Symbol.iterator]() {
+		for (const codec$1 of this._byId.values()) yield codec$1;
+	}
+	/**
+	* Returns an iterable of all registered codecs.
+	*/
+	values() {
+		return this._byId.values();
+	}
+};
+/**
+* Codec factory - creates a codec with typeId and encode/decode functions.
+* Provides identity defaults for encodeJson/decodeJson when not supplied.
+*/
+function codec(config) {
+	const identity = (v) => v;
+	return {
+		id: config.typeId,
+		targetTypes: config.targetTypes,
+		...ifDefined("meta", config.meta),
+		...ifDefined("paramsSchema", config.paramsSchema),
+		...ifDefined("init", config.init),
+		...ifDefined("traits", config.traits ? Object.freeze([...config.traits]) : void 0),
+		...ifDefined("renderOutputType", config.renderOutputType),
+		encode: config.encode,
+		decode: config.decode,
+		encodeJson: config.encodeJson ?? identity,
+		decodeJson: config.decodeJson ?? identity
+	};
+}
+/**
+* Implementation of CodecDefBuilder.
+*/
+var CodecDefBuilderImpl = class CodecDefBuilderImpl {
+	_codecs;
+	CodecTypes;
+	dataTypes;
+	constructor(codecs$1) {
+		this._codecs = codecs$1;
+		const codecTypes = {};
+		for (const [, codecImpl] of Object.entries(this._codecs)) {
+			const codecImplTyped = codecImpl;
+			codecTypes[codecImplTyped.id] = {
+				input: void 0,
+				output: void 0,
+				traits: void 0
+			};
+		}
+		this.CodecTypes = codecTypes;
+		const dataTypes = {};
+		for (const key in this._codecs) if (Object.hasOwn(this._codecs, key)) dataTypes[key] = this._codecs[key].id;
+		this.dataTypes = dataTypes;
+	}
+	add(scalarName, codecImpl) {
+		return new CodecDefBuilderImpl({
+			...this._codecs,
+			[scalarName]: codecImpl
+		});
+	}
+	/**
+	* Derive codecDefinitions structure.
+	*/
+	get codecDefinitions() {
+		const result = {};
+		for (const [scalarName, codecImpl] of Object.entries(this._codecs)) {
+			const codec$1 = codecImpl;
+			result[scalarName] = {
+				typeId: codec$1.id,
+				scalar: scalarName,
+				codec: codec$1,
+				input: void 0,
+				output: void 0,
+				jsType: void 0
+			};
+		}
+		return result;
+	}
+};
+/**
+* Create a new codec registry.
+*/
+function createCodecRegistry() {
+	return new CodecRegistryImpl();
+}
+/**
+* Create a new codec definition builder.
+*/
+function defineCodecs() {
+	return new CodecDefBuilderImpl({});
+}
+
+//#endregion
+//#region src/ast/sql-codecs.ts
+const SQL_CHAR_CODEC_ID = "sql/char@1";
+const SQL_VARCHAR_CODEC_ID = "sql/varchar@1";
+const SQL_INT_CODEC_ID = "sql/int@1";
+const SQL_FLOAT_CODEC_ID = "sql/float@1";
+const SQL_TEXT_CODEC_ID = "sql/text@1";
+const SQL_TIMESTAMP_CODEC_ID = "sql/timestamp@1";
+const lengthParamsSchema = type({ length: "number.integer > 0" });
+const precisionParamsSchema = type({ "precision?": "number.integer >= 0 & number.integer <= 6" });
+function createLengthTypeHelper(kind) {
+	return (params) => ({
+		kind,
+		maxLength: params["length"]
+	});
+}
+const sqlCharCodec = codec({
+	typeId: SQL_CHAR_CODEC_ID,
+	targetTypes: ["char"],
+	traits: [
+		"equality",
+		"order",
+		"textual"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire.trimEnd(),
+	paramsSchema: lengthParamsSchema,
+	init: createLengthTypeHelper("fixed"),
+	renderOutputType: (typeParams) => {
+		const length = typeParams["length"];
+		if (length === void 0) return void 0;
+		if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for Char, got ${String(length)}`);
+		return `Char<${length}>`;
+	}
+});
+const sqlVarcharCodec = codec({
+	typeId: SQL_VARCHAR_CODEC_ID,
+	targetTypes: ["varchar"],
+	traits: [
+		"equality",
+		"order",
+		"textual"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire,
+	paramsSchema: lengthParamsSchema,
+	init: createLengthTypeHelper("variable"),
+	renderOutputType: (typeParams) => {
+		const length = typeParams["length"];
+		if (length === void 0) return void 0;
+		if (typeof length !== "number" || !Number.isFinite(length) || !Number.isInteger(length)) throw new Error(`renderOutputType: expected integer "length" in typeParams for Varchar, got ${String(length)}`);
+		return `Varchar<${length}>`;
+	}
+});
+const sqlIntCodec = codec({
+	typeId: SQL_INT_CODEC_ID,
+	targetTypes: ["int"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire
+});
+const sqlFloatCodec = codec({
+	typeId: SQL_FLOAT_CODEC_ID,
+	targetTypes: ["float"],
+	traits: [
+		"equality",
+		"order",
+		"numeric"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire
+});
+const sqlTextCodec = codec({
+	typeId: SQL_TEXT_CODEC_ID,
+	targetTypes: ["text"],
+	traits: [
+		"equality",
+		"order",
+		"textual"
+	],
+	encode: (value) => value,
+	decode: (wire) => wire
+});
+const sqlTimestampCodec = codec({
+	typeId: SQL_TIMESTAMP_CODEC_ID,
+	targetTypes: ["timestamp"],
+	traits: ["equality", "order"],
+	encode: (value) => value instanceof Date ? value.toISOString() : value,
+	decode: (wire) => wire instanceof Date ? wire.toISOString() : wire,
+	paramsSchema: precisionParamsSchema,
+	renderOutputType: (typeParams) => {
+		const precision = typeParams["precision"];
+		if (precision === void 0) return "Timestamp";
+		if (typeof precision !== "number" || !Number.isFinite(precision) || !Number.isInteger(precision)) throw new Error(`renderOutputType: expected integer "precision" in typeParams for Timestamp, got ${String(precision)}`);
+		return `Timestamp<${precision}>`;
+	}
+});
+const codecs = defineCodecs().add("char", sqlCharCodec).add("varchar", sqlVarcharCodec).add("int", sqlIntCodec).add("float", sqlFloatCodec).add("text", sqlTextCodec).add("timestamp", sqlTimestampCodec);
+const sqlCodecDefinitions = codecs.codecDefinitions;
+const sqlDataTypes = codecs.dataTypes;
+
+//#endregion
+//#region src/ast/types.ts
+function frozenArrayCopy(values) {
+	return Object.freeze([...values]);
+}
+function frozenOptionalRecordCopy(value) {
+	return value === void 0 ? void 0 : Object.freeze({ ...value });
+}
+function frozenRecordCopy(record) {
+	return Object.freeze({ ...record });
+}
+function freezeRows(rows) {
+	return Object.freeze(rows.map((row) => Object.freeze({ ...row })));
+}
+function combineAll(folder, thunks) {
+	let result = folder.empty;
+	for (const thunk of thunks) {
+		if (folder.isAbsorbing?.(result)) return result;
+		result = folder.combine(result, thunk());
+	}
+	return result;
+}
+function rewriteComparable(value, rewriter) {
+	switch (value.kind) {
+		case "param-ref": return rewriter.paramRef ? rewriter.paramRef(value) : value;
+		case "literal": return rewriter.literal ? rewriter.literal(value) : value;
+		case "list":
+			if (rewriter.list) return rewriter.list(value);
+			return value.rewrite(rewriter);
+		default: return value.rewrite(rewriter);
+	}
+}
+function foldComparable(value, folder) {
+	switch (value.kind) {
+		case "param-ref": return folder.paramRef ? folder.paramRef(value) : folder.empty;
+		case "literal": return folder.literal ? folder.literal(value) : folder.empty;
+		case "list": return value.fold(folder);
+		default: return value.fold(folder);
+	}
+}
+function collectColumnRefsWith(node) {
+	return node.fold({
+		empty: [],
+		combine: (a, b) => [...a, ...b],
+		columnRef: (columnRef) => [columnRef],
+		select: (ast) => ast.collectColumnRefs()
+	});
+}
+function collectParamRefsWith(node) {
+	return node.fold({
+		empty: [],
+		combine: (a, b) => [...a, ...b],
+		paramRef: (paramRef) => [paramRef],
+		select: (ast) => ast.collectParamRefs()
+	});
+}
+function sortRefs(tables, columns) {
+	return {
+		tables: [...tables].sort((a, b) => a.localeCompare(b)),
+		columns: [...columns.values()].sort((a, b) => {
+			const tableCompare = a.table.localeCompare(b.table);
+			if (tableCompare !== 0) return tableCompare;
+			return a.column.localeCompare(b.column);
+		})
+	};
+}
+function addColumnRefToRefSets(columnRef, tables, columns) {
+	if (columnRef.table === "excluded") return;
+	tables.add(columnRef.table);
+	const key = `${columnRef.table}.${columnRef.column}`;
+	if (!columns.has(key)) columns.set(key, {
+		table: columnRef.table,
+		column: columnRef.column
+	});
+}
+function mergeRefsInto(refs, tables, columns) {
+	for (const table of refs.tables ?? []) tables.add(table);
+	for (const column of refs.columns ?? []) addColumnRefToRefSets(new ColumnRef(column.table, column.column), tables, columns);
+}
+var AstNode = class {
+	freeze() {
+		Object.freeze(this);
+	}
+};
+var QueryAst = class extends AstNode {
+	collectColumnRefs() {
+		return (this.collectRefs().columns ?? []).map((ref) => new ColumnRef(ref.table, ref.column));
+	}
+};
+var FromSource = class extends AstNode {};
+var Expression = class extends AstNode {
+	collectColumnRefs() {
+		return collectColumnRefsWith(this);
+	}
+	collectParamRefs() {
+		return collectParamRefsWith(this);
+	}
+	baseColumnRef() {
+		throw new Error(`${this.constructor.name} does not expose a base column reference`);
+	}
+	toExpr() {
+		return this;
+	}
+	not() {
+		return new NotExpr(this);
+	}
+};
+var TableSource = class TableSource extends FromSource {
+	kind = "table-source";
+	name;
+	alias;
+	constructor(name, alias) {
+		super();
+		this.name = name;
+		this.alias = alias;
+		this.freeze();
+	}
+	static named(name, alias) {
+		return new TableSource(name, alias);
+	}
+	rewrite(rewriter) {
+		return rewriter.tableSource ? rewriter.tableSource(this) : this;
+	}
+	toFromSource() {
+		return this;
+	}
+	collectRefs() {
+		return {
+			tables: [this.name],
+			columns: []
+		};
+	}
+};
+var DerivedTableSource = class DerivedTableSource extends FromSource {
+	kind = "derived-table-source";
+	alias;
+	query;
+	constructor(alias, query) {
+		super();
+		this.alias = alias;
+		this.query = query;
+		this.freeze();
+	}
+	static as(alias, query) {
+		return new DerivedTableSource(alias, query);
+	}
+	rewrite(rewriter) {
+		return new DerivedTableSource(this.alias, this.query.rewrite(rewriter));
+	}
+	toFromSource() {
+		return this;
+	}
+	collectRefs() {
+		return this.query.collectRefs();
+	}
+};
+var ColumnRef = class ColumnRef extends Expression {
+	kind = "column-ref";
+	table;
+	column;
+	constructor(table, column) {
+		super();
+		this.table = table;
+		this.column = column;
+		this.freeze();
+	}
+	static of(table, column) {
+		return new ColumnRef(table, column);
+	}
+	accept(visitor) {
+		return visitor.columnRef(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.columnRef ? rewriter.columnRef(this) : this;
+	}
+	fold(folder) {
+		return folder.columnRef ? folder.columnRef(this) : folder.empty;
+	}
+	baseColumnRef() {
+		return this;
+	}
+};
+var IdentifierRef = class IdentifierRef extends Expression {
+	kind = "identifier-ref";
+	name;
+	constructor(name) {
+		super();
+		this.name = name;
+		this.freeze();
+	}
+	static of(name) {
+		return new IdentifierRef(name);
+	}
+	accept(visitor) {
+		return visitor.identifierRef(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.identifierRef ? rewriter.identifierRef(this) : this;
+	}
+	fold(folder) {
+		return folder.identifierRef ? folder.identifierRef(this) : folder.empty;
+	}
+};
+var ParamRef = class ParamRef extends Expression {
+	kind = "param-ref";
+	value;
+	name;
+	codecId;
+	constructor(value, options) {
+		super();
+		this.value = value;
+		this.name = options?.name;
+		this.codecId = options?.codecId;
+		this.freeze();
+	}
+	static of(value, options) {
+		return new ParamRef(value, options);
+	}
+	accept(visitor) {
+		return visitor.param(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.paramRef ? rewriter.paramRef(this) : this;
+	}
+	fold(folder) {
+		return folder.paramRef ? folder.paramRef(this) : folder.empty;
+	}
+};
+var DefaultValueExpr = class extends AstNode {
+	kind = "default-value";
+	constructor() {
+		super();
+		this.freeze();
+	}
+};
+var LiteralExpr = class LiteralExpr extends Expression {
+	kind = "literal";
+	value;
+	constructor(value) {
+		super();
+		this.value = value;
+		this.freeze();
+	}
+	static of(value) {
+		return new LiteralExpr(value);
+	}
+	accept(visitor) {
+		return visitor.literal(this);
+	}
+	rewrite(rewriter) {
+		return rewriter.literal ? rewriter.literal(this) : this;
+	}
+	fold(folder) {
+		return folder.literal ? folder.literal(this) : folder.empty;
+	}
+};
+var SubqueryExpr = class SubqueryExpr extends Expression {
+	kind = "subquery";
+	query;
+	constructor(query) {
+		super();
+		this.query = query;
+		this.freeze();
+	}
+	static of(query) {
+		return new SubqueryExpr(query);
+	}
+	accept(visitor) {
+		return visitor.subquery(this);
+	}
+	rewrite(rewriter) {
+		return new SubqueryExpr(this.query.rewrite(rewriter));
+	}
+	fold(folder) {
+		return folder.select ? folder.select(this.query) : folder.empty;
+	}
+};
+var OperationExpr = class OperationExpr extends Expression {
+	kind = "operation";
+	method;
+	self;
+	args;
+	returns;
+	lowering;
+	constructor(options) {
+		super();
+		this.method = options.method;
+		this.self = options.self;
+		this.args = frozenArrayCopy(options.args ?? []);
+		this.returns = options.returns;
+		this.lowering = options.lowering;
+		this.freeze();
+	}
+	accept(visitor) {
+		return visitor.operation(this);
+	}
+	rewrite(rewriter) {
+		return new OperationExpr({
+			method: this.method,
+			self: this.self.rewrite(rewriter),
+			args: this.args.map((arg) => rewriteComparable(arg, rewriter)),
+			returns: this.returns,
+			lowering: this.lowering
+		});
+	}
+	fold(folder) {
+		return combineAll(folder, [() => this.self.fold(folder), ...this.args.map((arg) => () => foldComparable(arg, folder))]);
+	}
+	baseColumnRef() {
+		return this.self.baseColumnRef();
+	}
+};
+var AggregateExpr = class AggregateExpr extends Expression {
+	kind = "aggregate";
+	fn;
+	expr;
+	constructor(fn, expr) {
+		super();
+		if (fn !== "count" && expr === void 0) throw new Error(`Aggregate function "${fn}" requires an expression`);
+		this.fn = fn;
+		this.expr = expr;
+		this.freeze();
+	}
+	static count(expr) {
+		return new AggregateExpr("count", expr);
+	}
+	static sum(expr) {
+		return new AggregateExpr("sum", expr);
+	}
+	static avg(expr) {
+		return new AggregateExpr("avg", expr);
+	}
+	static min(expr) {
+		return new AggregateExpr("min", expr);
+	}
+	static max(expr) {
+		return new AggregateExpr("max", expr);
+	}
+	accept(visitor) {
+		return visitor.aggregate(this);
+	}
+	rewrite(rewriter) {
+		return this.expr === void 0 ? this : new AggregateExpr(this.fn, this.expr.rewrite(rewriter));
+	}
+	fold(folder) {
+		return this.expr ? this.expr.fold(folder) : folder.empty;
+	}
+};
+var JsonObjectExpr = class JsonObjectExpr extends Expression {
+	kind = "json-object";
+	entries;
+	constructor(entries) {
+		super();
+		this.entries = frozenArrayCopy(entries.map((entry) => Object.freeze({ ...entry })));
+		this.freeze();
+	}
+	static entry(key, value) {
+		return {
+			key,
+			value
+		};
+	}
+	static fromEntries(entries) {
+		return new JsonObjectExpr(entries);
+	}
+	accept(visitor) {
+		return visitor.jsonObject(this);
+	}
+	rewrite(rewriter) {
+		return new JsonObjectExpr(this.entries.map((entry) => ({
+			key: entry.key,
+			value: entry.value.kind === "literal" ? rewriter.literal ? rewriter.literal(entry.value) : entry.value : entry.value.rewrite(rewriter)
+		})));
+	}
+	fold(folder) {
+		return combineAll(folder, this.entries.map((entry) => () => entry.value.kind === "literal" ? folder.literal ? folder.literal(entry.value) : folder.empty : entry.value.fold(folder)));
+	}
+};
+var OrderByItem = class OrderByItem extends AstNode {
+	kind = "order-by-item";
+	expr;
+	dir;
+	constructor(expr, dir) {
+		super();
+		this.expr = expr;
+		this.dir = dir;
+		this.freeze();
+	}
+	static asc(expr) {
+		return new OrderByItem(expr, "asc");
+	}
+	static desc(expr) {
+		return new OrderByItem(expr, "desc");
+	}
+	rewrite(rewriter) {
+		return new OrderByItem(this.expr.rewrite(rewriter), this.dir);
+	}
+};
+var JsonArrayAggExpr = class JsonArrayAggExpr extends Expression {
+	kind = "json-array-agg";
+	expr;
+	onEmpty;
+	orderBy;
+	constructor(expr, onEmpty = "null", orderBy) {
+		super();
+		this.expr = expr;
+		this.onEmpty = onEmpty;
+		this.orderBy = orderBy && orderBy.length > 0 ? frozenArrayCopy(orderBy) : void 0;
+		this.freeze();
+	}
+	static of(expr, onEmpty = "null", orderBy) {
+		return new JsonArrayAggExpr(expr, onEmpty, orderBy);
+	}
+	accept(visitor) {
+		return visitor.jsonArrayAgg(this);
+	}
+	rewrite(rewriter) {
+		return new JsonArrayAggExpr(this.expr.rewrite(rewriter), this.onEmpty, this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter)));
+	}
+	fold(folder) {
+		return combineAll(folder, [() => this.expr.fold(folder), ...(this.orderBy ?? []).map((orderItem) => () => orderItem.expr.fold(folder))]);
+	}
+};
+var ListExpression = class ListExpression extends Expression {
+	kind = "list";
+	values;
+	constructor(values) {
+		super();
+		this.values = frozenArrayCopy(values);
+		this.freeze();
+	}
+	static of(values) {
+		return new ListExpression(values);
+	}
+	static fromValues(values) {
+		return new ListExpression(values.map((value) => new LiteralExpr(value)));
+	}
+	accept(visitor) {
+		return visitor.list(this);
+	}
+	rewrite(rewriter) {
+		if (rewriter.list) return rewriter.list(this);
+		return new ListExpression(this.values.map((value) => value.rewrite(rewriter)));
+	}
+	fold(folder) {
+		if (folder.list) return folder.list(this);
+		return combineAll(folder, this.values.map((value) => () => value.fold(folder)));
+	}
+};
+var BinaryExpr = class BinaryExpr extends Expression {
+	kind = "binary";
+	op;
+	left;
+	right;
+	constructor(op, left, right) {
+		super();
+		this.op = op;
+		this.left = left;
+		this.right = right;
+		this.freeze();
+	}
+	static eq(left, right) {
+		return new BinaryExpr("eq", left, right);
+	}
+	static neq(left, right) {
+		return new BinaryExpr("neq", left, right);
+	}
+	static gt(left, right) {
+		return new BinaryExpr("gt", left, right);
+	}
+	static lt(left, right) {
+		return new BinaryExpr("lt", left, right);
+	}
+	static gte(left, right) {
+		return new BinaryExpr("gte", left, right);
+	}
+	static lte(left, right) {
+		return new BinaryExpr("lte", left, right);
+	}
+	static like(left, right) {
+		return new BinaryExpr("like", left, right);
+	}
+	static ilike(left, right) {
+		return new BinaryExpr("ilike", left, right);
+	}
+	static in(left, right) {
+		return new BinaryExpr("in", left, right);
+	}
+	static notIn(left, right) {
+		return new BinaryExpr("notIn", left, right);
+	}
+	accept(visitor) {
+		return visitor.binary(this);
+	}
+	rewrite(rewriter) {
+		return new BinaryExpr(this.op, rewriteComparable(this.left, rewriter), rewriteComparable(this.right, rewriter));
+	}
+	fold(folder) {
+		return combineAll(folder, [() => foldComparable(this.left, folder), () => foldComparable(this.right, folder)]);
+	}
+};
+var AndExpr = class AndExpr extends Expression {
+	kind = "and";
+	exprs;
+	constructor(exprs) {
+		super();
+		this.exprs = frozenArrayCopy(exprs);
+		this.freeze();
+	}
+	static of(exprs) {
+		return new AndExpr(exprs);
+	}
+	static true() {
+		return new AndExpr([]);
+	}
+	accept(visitor) {
+		return visitor.and(this);
+	}
+	rewrite(rewriter) {
+		return new AndExpr(this.exprs.map((expr) => expr.rewrite(rewriter)));
+	}
+	fold(folder) {
+		return combineAll(folder, this.exprs.map((expr) => () => expr.fold(folder)));
+	}
+};
+var OrExpr = class OrExpr extends Expression {
+	kind = "or";
+	exprs;
+	constructor(exprs) {
+		super();
+		this.exprs = frozenArrayCopy(exprs);
+		this.freeze();
+	}
+	static of(exprs) {
+		return new OrExpr(exprs);
+	}
+	static false() {
+		return new OrExpr([]);
+	}
+	accept(visitor) {
+		return visitor.or(this);
+	}
+	rewrite(rewriter) {
+		return new OrExpr(this.exprs.map((expr) => expr.rewrite(rewriter)));
+	}
+	fold(folder) {
+		return combineAll(folder, this.exprs.map((expr) => () => expr.fold(folder)));
+	}
+};
+var ExistsExpr = class ExistsExpr extends Expression {
+	kind = "exists";
+	notExists;
+	subquery;
+	constructor(subquery, notExists = false) {
+		super();
+		this.notExists = notExists;
+		this.subquery = subquery;
+		this.freeze();
+	}
+	static exists(subquery) {
+		return new ExistsExpr(subquery, false);
+	}
+	static notExists(subquery) {
+		return new ExistsExpr(subquery, true);
+	}
+	accept(visitor) {
+		return visitor.exists(this);
+	}
+	rewrite(rewriter) {
+		return new ExistsExpr(this.subquery.rewrite(rewriter), this.notExists);
+	}
+	fold(folder) {
+		return folder.select ? folder.select(this.subquery) : folder.empty;
+	}
+};
+var NullCheckExpr = class NullCheckExpr extends Expression {
+	kind = "null-check";
+	expr;
+	isNull;
+	constructor(expr, isNull) {
+		super();
+		this.expr = expr;
+		this.isNull = isNull;
+		this.freeze();
+	}
+	static isNull(expr) {
+		return new NullCheckExpr(expr, true);
+	}
+	static isNotNull(expr) {
+		return new NullCheckExpr(expr, false);
+	}
+	accept(visitor) {
+		return visitor.nullCheck(this);
+	}
+	rewrite(rewriter) {
+		return new NullCheckExpr(this.expr.rewrite(rewriter), this.isNull);
+	}
+	fold(folder) {
+		return this.expr.fold(folder);
+	}
+};
+var NotExpr = class NotExpr extends Expression {
+	kind = "not";
+	expr;
+	constructor(expr) {
+		super();
+		this.expr = expr;
+		this.freeze();
+	}
+	toWhereExpr() {
+		return this;
+	}
+	accept(visitor) {
+		return visitor.not(this);
+	}
+	rewrite(rewriter) {
+		return new NotExpr(this.expr.rewrite(rewriter));
+	}
+	fold(folder) {
+		return this.expr.fold(folder);
+	}
+};
+var EqColJoinOn = class EqColJoinOn extends AstNode {
+	kind = "eq-col-join-on";
+	left;
+	right;
+	constructor(left, right) {
+		super();
+		this.left = left;
+		this.right = right;
+		this.freeze();
+	}
+	static of(left, right) {
+		return new EqColJoinOn(left, right);
+	}
+	rewrite(rewriter) {
+		return rewriter.eqColJoinOn ? rewriter.eqColJoinOn(this) : this;
+	}
+};
+var JoinAst = class JoinAst extends AstNode {
+	kind = "join";
+	joinType;
+	source;
+	lateral;
+	on;
+	constructor(joinType, source, on, lateral = false) {
+		super();
+		this.joinType = joinType;
+		this.source = source;
+		this.lateral = lateral;
+		this.on = on;
+		this.freeze();
+	}
+	static inner(source, on, lateral = false) {
+		return new JoinAst("inner", source, on, lateral);
+	}
+	static left(source, on, lateral = false) {
+		return new JoinAst("left", source, on, lateral);
+	}
+	static right(source, on, lateral = false) {
+		return new JoinAst("right", source, on, lateral);
+	}
+	static full(source, on, lateral = false) {
+		return new JoinAst("full", source, on, lateral);
+	}
+	rewrite(rewriter) {
+		return new JoinAst(this.joinType, this.source.rewrite(rewriter), this.on.kind === "eq-col-join-on" ? this.on.rewrite(rewriter) : this.on.rewrite(rewriter), this.lateral);
+	}
+};
+var ProjectionItem = class ProjectionItem extends AstNode {
+	kind = "projection-item";
+	alias;
+	expr;
+	constructor(alias, expr) {
+		super();
+		this.alias = alias;
+		this.expr = expr;
+		this.freeze();
+	}
+	static of(alias, expr) {
+		return new ProjectionItem(alias, expr);
+	}
+};
+var SelectAst = class SelectAst extends QueryAst {
+	kind = "select";
+	from;
+	joins;
+	projection;
+	where;
+	orderBy;
+	distinct;
+	distinctOn;
+	groupBy;
+	having;
+	limit;
+	offset;
+	selectAllIntent;
+	constructor(options) {
+		super();
+		this.from = options.from;
+		this.joins = options.joins && options.joins.length > 0 ? frozenArrayCopy(options.joins) : void 0;
+		this.projection = frozenArrayCopy(options.projection);
+		this.where = options.where;
+		this.orderBy = options.orderBy && options.orderBy.length > 0 ? frozenArrayCopy(options.orderBy) : void 0;
+		this.distinct = options.distinct;
+		this.distinctOn = options.distinctOn && options.distinctOn.length > 0 ? frozenArrayCopy(options.distinctOn) : void 0;
+		this.groupBy = options.groupBy && options.groupBy.length > 0 ? frozenArrayCopy(options.groupBy) : void 0;
+		this.having = options.having;
+		this.limit = options.limit;
+		this.offset = options.offset;
+		this.selectAllIntent = frozenOptionalRecordCopy(options.selectAllIntent);
+		this.freeze();
+	}
+	static from(from) {
+		return new SelectAst({
+			from,
+			joins: void 0,
+			projection: [],
+			where: void 0,
+			orderBy: void 0,
+			distinct: void 0,
+			distinctOn: void 0,
+			groupBy: void 0,
+			having: void 0,
+			limit: void 0,
+			offset: void 0,
+			selectAllIntent: void 0
+		});
+	}
+	withFrom(from) {
+		return new SelectAst({
+			...this,
+			from
+		});
+	}
+	withJoins(joins) {
+		return new SelectAst({
+			...this,
+			joins: joins.length > 0 ? joins : void 0
+		});
+	}
+	withProjection(projection) {
+		return new SelectAst({
+			...this,
+			projection
+		});
+	}
+	addProjection(alias, expr) {
+		return new SelectAst({
+			...this,
+			projection: [...this.projection, new ProjectionItem(alias, expr)]
+		});
+	}
+	withWhere(where) {
+		return new SelectAst({
+			...this,
+			where
+		});
+	}
+	withOrderBy(orderBy) {
+		return new SelectAst({
+			...this,
+			orderBy: orderBy.length > 0 ? orderBy : void 0
+		});
+	}
+	withDistinct(enabled = true) {
+		return new SelectAst({
+			...this,
+			distinct: enabled ? true : void 0
+		});
+	}
+	withDistinctOn(distinctOn) {
+		return new SelectAst({
+			...this,
+			distinctOn: distinctOn.length > 0 ? distinctOn : void 0
+		});
+	}
+	withGroupBy(groupBy) {
+		return new SelectAst({
+			...this,
+			groupBy: groupBy.length > 0 ? groupBy : void 0
+		});
+	}
+	withHaving(having) {
+		return new SelectAst({
+			...this,
+			having
+		});
+	}
+	withLimit(limit) {
+		return new SelectAst({
+			...this,
+			limit
+		});
+	}
+	withOffset(offset) {
+		return new SelectAst({
+			...this,
+			offset
+		});
+	}
+	withSelectAllIntent(selectAllIntent) {
+		return new SelectAst({
+			...this,
+			selectAllIntent
+		});
+	}
+	rewrite(rewriter) {
+		const rewritten = new SelectAst({
+			from: this.from.rewrite(rewriter),
+			joins: this.joins?.map((join) => join.rewrite(rewriter)),
+			projection: this.projection.map((projection) => new ProjectionItem(projection.alias, projection.expr.kind === "literal" ? rewriter.literal ? rewriter.literal(projection.expr) : projection.expr : projection.expr.rewrite(rewriter))),
+			where: this.where?.rewrite(rewriter),
+			orderBy: this.orderBy?.map((orderItem) => orderItem.rewrite(rewriter)),
+			distinct: this.distinct,
+			distinctOn: this.distinctOn?.map((expr) => expr.rewrite(rewriter)),
+			groupBy: this.groupBy?.map((expr) => expr.rewrite(rewriter)),
+			having: this.having?.rewrite(rewriter),
+			limit: this.limit,
+			offset: this.offset,
+			selectAllIntent: this.selectAllIntent
+		});
+		return rewriter.select ? rewriter.select(rewritten) : rewritten;
+	}
+	collectColumnRefs() {
+		const refs = [];
+		const pushRefs = (columns) => {
+			refs.push(...columns);
+		};
+		if (this.from.kind === "derived-table-source") pushRefs(this.from.query.collectColumnRefs());
+		for (const projection of this.projection) if (!(projection.expr.kind === "literal")) pushRefs(projection.expr.collectColumnRefs());
+		if (this.where) pushRefs(this.where.collectColumnRefs());
+		if (this.having) pushRefs(this.having.collectColumnRefs());
+		for (const orderItem of this.orderBy ?? []) pushRefs(orderItem.expr.collectColumnRefs());
+		for (const expr of this.distinctOn ?? []) pushRefs(expr.collectColumnRefs());
+		for (const expr of this.groupBy ?? []) pushRefs(expr.collectColumnRefs());
+		for (const join of this.joins ?? []) {
+			if (join.source.kind === "derived-table-source") pushRefs(join.source.query.collectColumnRefs());
+			if (join.on.kind === "eq-col-join-on") refs.push(join.on.left, join.on.right);
+			else pushRefs(join.on.collectColumnRefs());
+		}
+		return refs;
+	}
+	collectParamRefs() {
+		const refs = [];
+		const pushRefs = (params) => {
+			refs.push(...params);
+		};
+		if (this.from.kind === "derived-table-source") pushRefs(this.from.query.collectParamRefs());
+		for (const projection of this.projection) if (!(projection.expr.kind === "literal")) pushRefs(projection.expr.collectParamRefs());
+		if (this.where) pushRefs(this.where.collectParamRefs());
+		if (this.having) pushRefs(this.having.collectParamRefs());
+		for (const orderItem of this.orderBy ?? []) pushRefs(orderItem.expr.collectParamRefs());
+		for (const expr of this.distinctOn ?? []) pushRefs(expr.collectParamRefs());
+		for (const expr of this.groupBy ?? []) pushRefs(expr.collectParamRefs());
+		for (const join of this.joins ?? []) {
+			if (join.source.kind === "derived-table-source") pushRefs(join.source.query.collectParamRefs());
+			if (!(join.on.kind === "eq-col-join-on")) pushRefs(join.on.collectParamRefs());
+		}
+		return refs;
+	}
+	collectRefs() {
+		const tables = /* @__PURE__ */ new Set();
+		const columns = /* @__PURE__ */ new Map();
+		const addSource = (source) => {
+			mergeRefsInto(source.collectRefs(), tables, columns);
+		};
+		addSource(this.from);
+		for (const join of this.joins ?? []) {
+			addSource(join.source);
+			if (join.on.kind === "eq-col-join-on") {
+				addColumnRefToRefSets(join.on.left, tables, columns);
+				addColumnRefToRefSets(join.on.right, tables, columns);
+			} else for (const columnRef of join.on.collectColumnRefs()) addColumnRefToRefSets(columnRef, tables, columns);
+		}
+		for (const columnRef of this.collectColumnRefs()) addColumnRefToRefSets(columnRef, tables, columns);
+		return sortRefs(tables, columns);
+	}
+	toQueryAst() {
+		return this;
+	}
+};
+var InsertOnConflictAction = class extends AstNode {};
+var DoNothingConflictAction = class extends InsertOnConflictAction {
+	kind = "do-nothing";
+	constructor() {
+		super();
+		this.freeze();
+	}
+	toInsertOnConflictAction() {
+		return this;
+	}
+};
+var DoUpdateSetConflictAction = class extends InsertOnConflictAction {
+	kind = "do-update-set";
+	set;
+	constructor(set) {
+		super();
+		this.set = frozenRecordCopy(set);
+		this.freeze();
+	}
+	toInsertOnConflictAction() {
+		return this;
+	}
+};
+var InsertOnConflict = class InsertOnConflict extends AstNode {
+	kind = "insert-on-conflict";
+	columns;
+	action;
+	constructor(columns, action) {
+		super();
+		this.columns = frozenArrayCopy(columns);
+		this.action = action;
+		this.freeze();
+	}
+	static on(columns) {
+		return new InsertOnConflict(columns, new DoNothingConflictAction());
+	}
+	doNothing() {
+		return new InsertOnConflict(this.columns, new DoNothingConflictAction());
+	}
+	doUpdateSet(set) {
+		return new InsertOnConflict(this.columns, new DoUpdateSetConflictAction(set));
+	}
+};
+var InsertAst = class InsertAst extends QueryAst {
+	kind = "insert";
+	table;
+	rows;
+	onConflict;
+	returning;
+	constructor(table, rows = [{}], onConflict, returning) {
+		super();
+		this.table = table;
+		this.rows = freezeRows(rows);
+		this.onConflict = onConflict;
+		this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0;
+		this.freeze();
+	}
+	static into(table) {
+		return new InsertAst(table);
+	}
+	withValues(values) {
+		return new InsertAst(this.table, [{ ...values }], this.onConflict, this.returning);
+	}
+	withRows(rows) {
+		return new InsertAst(this.table, rows.map((row) => ({ ...row })), this.onConflict, this.returning);
+	}
+	withReturning(returning) {
+		return new InsertAst(this.table, this.rows.map((row) => ({ ...row })), this.onConflict, returning);
+	}
+	withOnConflict(onConflict) {
+		return new InsertAst(this.table, this.rows.map((row) => ({ ...row })), onConflict, this.returning);
+	}
+	collectParamRefs() {
+		const refs = [];
+		for (const row of this.rows) for (const value of Object.values(row)) if (value.kind === "param-ref") refs.push(value);
+		if (this.onConflict?.action.kind === "do-update-set") {
+			for (const value of Object.values(this.onConflict.action.set)) if (value.kind === "param-ref") refs.push(value);
+		}
+		return refs;
+	}
+	collectRefs() {
+		const tables = new Set([this.table.name]);
+		const columns = /* @__PURE__ */ new Map();
+		const addColumn = (columnRef) => addColumnRefToRefSets(columnRef, tables, columns);
+		const addValue = (value) => {
+			if (value.kind === "column-ref") addColumn(value);
+		};
+		for (const row of this.rows) for (const value of Object.values(row)) addValue(value);
+		for (const columnRef of this.returning ?? []) addColumn(columnRef);
+		if (this.onConflict) {
+			for (const columnRef of this.onConflict.columns) addColumn(columnRef);
+			if (this.onConflict.action.kind === "do-update-set") {
+				for (const value of Object.values(this.onConflict.action.set)) if (value.kind === "column-ref") addColumn(value);
+			}
+		}
+		return sortRefs(tables, columns);
+	}
+	toQueryAst() {
+		return this;
+	}
+};
+var UpdateAst = class UpdateAst extends QueryAst {
+	kind = "update";
+	table;
+	set;
+	where;
+	returning;
+	constructor(table, set = {}, where, returning) {
+		super();
+		this.table = table;
+		this.set = frozenRecordCopy(set);
+		this.where = where;
+		this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0;
+		this.freeze();
+	}
+	static table(table) {
+		return new UpdateAst(table);
+	}
+	withSet(set) {
+		return new UpdateAst(this.table, set, this.where, this.returning);
+	}
+	withWhere(where) {
+		return new UpdateAst(this.table, this.set, where, this.returning);
+	}
+	withReturning(returning) {
+		return new UpdateAst(this.table, this.set, this.where, returning);
+	}
+	collectParamRefs() {
+		const refs = [];
+		for (const value of Object.values(this.set)) if (value.kind === "param-ref") refs.push(value);
+		if (this.where) refs.push(...this.where.collectParamRefs());
+		return refs;
+	}
+	collectRefs() {
+		const tables = new Set([this.table.name]);
+		const columns = /* @__PURE__ */ new Map();
+		for (const value of Object.values(this.set)) if (value.kind === "column-ref") addColumnRefToRefSets(value, tables, columns);
+		for (const columnRef of this.where?.collectColumnRefs() ?? []) addColumnRefToRefSets(columnRef, tables, columns);
+		for (const columnRef of this.returning ?? []) addColumnRefToRefSets(columnRef, tables, columns);
+		return sortRefs(tables, columns);
+	}
+	toQueryAst() {
+		return this;
+	}
+};
+var DeleteAst = class DeleteAst extends QueryAst {
+	kind = "delete";
+	table;
+	where;
+	returning;
+	constructor(table, where, returning) {
+		super();
+		this.table = table;
+		this.where = where;
+		this.returning = returning && returning.length > 0 ? frozenArrayCopy(returning) : void 0;
+		this.freeze();
+	}
+	static from(table) {
+		return new DeleteAst(table);
+	}
+	withWhere(where) {
+		return new DeleteAst(this.table, where, this.returning);
+	}
+	withReturning(returning) {
+		return new DeleteAst(this.table, this.where, returning);
+	}
+	collectParamRefs() {
+		return this.where?.collectParamRefs() ?? [];
+	}
+	collectRefs() {
+		const tables = new Set([this.table.name]);
+		const columns = /* @__PURE__ */ new Map();
+		for (const columnRef of this.where?.collectColumnRefs() ?? []) addColumnRefToRefSets(columnRef, tables, columns);
+		for (const columnRef of this.returning ?? []) addColumnRefToRefSets(columnRef, tables, columns);
+		return sortRefs(tables, columns);
+	}
+	toQueryAst() {
+		return this;
+	}
+};
+const queryAstKinds = new Set([
+	"select",
+	"insert",
+	"update",
+	"delete"
+]);
+const whereExprKinds = new Set([
+	"binary",
+	"and",
+	"or",
+	"exists",
+	"null-check",
+	"not"
+]);
+function isQueryAst(value) {
+	return typeof value === "object" && value !== null && "kind" in value && queryAstKinds.has(value.kind);
+}
+function isWhereExpr(value) {
+	return typeof value === "object" && value !== null && "kind" in value && whereExprKinds.has(value.kind);
+}
+
+//#endregion
+//#region src/ast/util.ts
+function compact(o) {
+	const out = {};
+	for (const [k, v] of Object.entries(o)) {
+		if (v === void 0 || v === null) continue;
+		if (Array.isArray(v) && v.length === 0) continue;
+		out[k] = v;
+	}
+	return out;
+}
+
+//#endregion
+export { AggregateExpr, AndExpr, BinaryExpr, ColumnRef, DefaultValueExpr, DeleteAst, DerivedTableSource, DoNothingConflictAction, DoUpdateSetConflictAction, EqColJoinOn, ExistsExpr, IdentifierRef, InsertAst, InsertOnConflict, JoinAst, JsonArrayAggExpr, JsonObjectExpr, ListExpression, LiteralExpr, NotExpr, NullCheckExpr, OperationExpr, OrExpr, OrderByItem, ParamRef, ProjectionItem, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID, SelectAst, SubqueryExpr, TableSource, UpdateAst, codec, compact, createCodecRegistry, defineCodecs, isQueryAst, isWhereExpr, queryAstKinds, sqlCodecDefinitions, sqlDataTypes, whereExprKinds };
+//# sourceMappingURL=ast.mjs.map