@prisma-next/sql-relational-core 0.5.0-dev.60 → 0.5.0-dev.62

package/dist/exports/ast.mjs

@@ -1,296 +1,236 @@
-import { A as UpdateAst, C as OrExpr, D as SelectAst, E as ProjectionItem, M as isWhereExpr, N as queryAstKinds, O as SubqueryExpr, P as whereExprKinds, S as OperationExpr, T as ParamRef, _ as JsonObjectExpr, a as DefaultValueExpr, b as NotExpr, c as DoNothingConflictAction, d as ExistsExpr, f as IdentifierRef, g as JsonArrayAggExpr, h as JoinAst, i as ColumnRef, j as isQueryAst, k as TableSource, l as DoUpdateSetConflictAction, m as InsertOnConflict, n as AndExpr, o as DeleteAst, p as InsertAst, r as BinaryExpr, s as DerivedTableSource, t as AggregateExpr, u as EqColJoinOn, v as ListExpression, w as OrderByItem, x as NullCheckExpr, y as LiteralExpr } from "../types-DUL-3vy6.mjs";
-import { ifDefined } from "@prisma-next/utils/defined";
+import { A as UpdateAst, C as OrExpr, D as SelectAst, E as ProjectionItem, M as isWhereExpr, N as queryAstKinds, O as SubqueryExpr, P as whereExprKinds, S as OperationExpr, T as ParamRef, _ as JsonObjectExpr, a as DefaultValueExpr, b as NotExpr, c as DoNothingConflictAction, d as ExistsExpr, f as IdentifierRef, g as JsonArrayAggExpr, h as JoinAst, i as ColumnRef, j as isQueryAst, k as TableSource, l as DoUpdateSetConflictAction, m as InsertOnConflict, n as AndExpr, o as DeleteAst, p as InsertAst, r as BinaryExpr, s as DerivedTableSource, t as AggregateExpr, u as EqColJoinOn, v as ListExpression, w as OrderByItem, x as NullCheckExpr, y as LiteralExpr } from "../types-CO7zrXfK.mjs";
+import { CodecDescriptorImpl, CodecImpl, column, voidParamsSchema } from "@prisma-next/framework-components/codec";
 import { type } from "arktype";
+import { runtimeError } from "@prisma-next/framework-components/runtime";
 
-//#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();
-	}
-};
-/**
-* Construct a SQL codec from author functions and optional metadata.
-*
-* Author `encode` and `decode` as sync or async functions; the factory
-* produces a {@link Codec} whose query-time methods follow the boundary
-* contract documented on `Codec`. Authors receive a second `ctx` options
-* argument carrying the SQL-family per-call context; ignore it if you
-* don't need it.
-*
-* Both `encode` and `decode` are required so `TInput` and `TWire` are
-* always covered by an explicit author function — the factory installs
-* no identity fallback. `encodeJson` and `decodeJson` default to identity
-* **only when `TInput` is assignable to `JsonValue`**; otherwise both are
-* required so the contract artifact stays JSON-safe.
-*/
-function codec(config) {
-	const identity = (v) => v;
-	const userEncode = config.encode;
-	const userDecode = config.decode;
-	const widenedConfig = config;
-	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: (value, ctx) => {
-			try {
-				return Promise.resolve(userEncode(value, ctx));
-			} catch (error) {
-				return Promise.reject(error);
-			}
-		},
-		decode: (wire, ctx) => {
-			try {
-				return Promise.resolve(userDecode(wire, ctx));
-			} catch (error) {
-				return Promise.reject(error);
-			}
-		},
-		encodeJson: widenedConfig.encodeJson ?? identity,
-		decodeJson: widenedConfig.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
+//#region src/ast/sql-codec-helpers.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 sqlCharEncode = (value) => value;
+const sqlCharDecode = (wire) => wire.trimEnd();
+const sqlCharRenderOutputType = (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 sqlVarcharEncode = (value) => value;
+const sqlVarcharDecode = (wire) => wire;
+const sqlVarcharRenderOutputType = (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 sqlIntEncode = (value) => value;
+const sqlIntDecode = (wire) => wire;
+const sqlFloatEncode = (value) => value;
+const sqlFloatDecode = (wire) => wire;
+const sqlTextEncode = (value) => value;
+const sqlTextDecode = (wire) => wire;
+const sqlTimestampEncode = (value) => value;
+const sqlTimestampDecode = (wire) => wire;
+const sqlTimestampEncodeJson = (value) => value.toISOString();
+const sqlTimestampDecodeJson = (json) => {
+	if (typeof json !== "string") throw new Error(`Expected ISO date string for sql/timestamp@1, got ${typeof json}`);
+	const date = new Date(json);
+	if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for sql/timestamp@1: ${json}`);
+	return date;
+};
+const sqlTimestampRenderOutputType = (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}>`;
+};
+
+//#endregion
+//#region src/ast/sql-codecs.ts
+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: [
+var SqlTextCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlTextEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return sqlTextDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var SqlTextDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_TEXT_CODEC_ID;
+	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: [
+	];
+	targetTypes = ["text"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new SqlTextCodec(this);
+	}
+};
+const sqlTextDescriptor = new SqlTextDescriptor();
+const sqlTextColumn = () => column(sqlTextDescriptor.factory(), sqlTextDescriptor.codecId, void 0, "text");
+var SqlIntCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlIntEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return sqlIntDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var SqlIntDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_INT_CODEC_ID;
+	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: [
+		"numeric"
+	];
+	targetTypes = ["int"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new SqlIntCodec(this);
+	}
+};
+const sqlIntDescriptor = new SqlIntDescriptor();
+const sqlIntColumn = () => column(sqlIntDescriptor.factory(), sqlIntDescriptor.codecId, void 0, "int");
+var SqlFloatCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlFloatEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return sqlFloatDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var SqlFloatDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_FLOAT_CODEC_ID;
+	traits = [
 		"equality",
 		"order",
 		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire
-});
-const sqlFloatCodec = codec({
-	typeId: SQL_FLOAT_CODEC_ID,
-	targetTypes: ["float"],
-	traits: [
+	];
+	targetTypes = ["float"];
+	paramsSchema = voidParamsSchema;
+	factory() {
+		return () => new SqlFloatCodec(this);
+	}
+};
+const sqlFloatDescriptor = new SqlFloatDescriptor();
+const sqlFloatColumn = () => column(sqlFloatDescriptor.factory(), sqlFloatDescriptor.codecId, void 0, "float");
+var SqlCharCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlCharEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return sqlCharDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var SqlCharDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_CHAR_CODEC_ID;
+	traits = [
 		"equality",
 		"order",
-		"numeric"
-	],
-	encode: (value) => value,
-	decode: (wire) => wire
-});
-const sqlTextCodec = codec({
-	typeId: SQL_TEXT_CODEC_ID,
-	targetTypes: ["text"],
-	traits: [
+		"textual"
+	];
+	targetTypes = ["char"];
+	paramsSchema = lengthParamsSchema;
+	renderOutputType(params) {
+		return sqlCharRenderOutputType(params);
+	}
+	factory(_params) {
+		return () => new SqlCharCodec(this);
+	}
+};
+const sqlCharDescriptor = new SqlCharDescriptor();
+const sqlCharColumn = (params = {}) => column(sqlCharDescriptor.factory(params), sqlCharDescriptor.codecId, params, "char");
+var SqlVarcharCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlVarcharEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return sqlVarcharDecode(wire);
+	}
+	encodeJson(value) {
+		return value;
+	}
+	decodeJson(json) {
+		return json;
+	}
+};
+var SqlVarcharDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_VARCHAR_CODEC_ID;
+	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,
-	decode: (wire) => wire,
-	encodeJson: (value) => value.toISOString(),
-	decodeJson: (json) => {
-		if (typeof json !== "string") throw new Error(`Expected ISO date string for sql/timestamp@1, got ${typeof json}`);
-		const date = new Date(json);
-		if (Number.isNaN(date.getTime())) throw new Error(`Invalid ISO date string for sql/timestamp@1: ${json}`);
-		return date;
-	},
-	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;
+	];
+	targetTypes = ["varchar"];
+	paramsSchema = lengthParamsSchema;
+	renderOutputType(params) {
+		return sqlVarcharRenderOutputType(params);
+	}
+	factory(_params) {
+		return () => new SqlVarcharCodec(this);
+	}
+};
+const sqlVarcharDescriptor = new SqlVarcharDescriptor();
+const sqlVarcharColumn = (params = {}) => column(sqlVarcharDescriptor.factory(params), sqlVarcharDescriptor.codecId, params, "varchar");
+var SqlTimestampCodec = class extends CodecImpl {
+	async encode(value, _ctx) {
+		return sqlTimestampEncode(value);
+	}
+	async decode(wire, _ctx) {
+		return sqlTimestampDecode(wire);
+	}
+	encodeJson(value) {
+		return sqlTimestampEncodeJson(value);
+	}
+	decodeJson(json) {
+		return sqlTimestampDecodeJson(json);
+	}
+};
+var SqlTimestampDescriptor = class extends CodecDescriptorImpl {
+	codecId = SQL_TIMESTAMP_CODEC_ID;
+	traits = ["equality", "order"];
+	targetTypes = ["timestamp"];
+	paramsSchema = precisionParamsSchema;
+	renderOutputType(params) {
+		return sqlTimestampRenderOutputType(params);
+	}
+	factory(_params) {
+		return () => new SqlTimestampCodec(this);
+	}
+};
+const sqlTimestampDescriptor = new SqlTimestampDescriptor();
+const sqlTimestampColumn = (params = {}) => column(sqlTimestampDescriptor.factory(params), sqlTimestampDescriptor.codecId, params, "timestamp");
 
 //#endregion
 //#region src/ast/util.ts
@@ -325,5 +265,35 @@ function collectOrderedParamRefs(ast) {
 }
 
 //#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, collectOrderedParamRefs, compact, createCodecRegistry, defineCodecs, isQueryAst, isWhereExpr, queryAstKinds, sqlCodecDefinitions, sqlDataTypes, whereExprKinds };
+//#region src/ast/validate-param-refs.ts
+/**
+* Builder-pipeline validator pass: every {@link ParamRef} whose `codecId` resolves to a *parameterized* descriptor must carry `refs: { table, column }` so encode-side dispatch can call `contractCodecs.forColumn(table, column)`. Refs-less parameterized `ParamRef`s are a hard error — the codec-id-keyed `forCodecId` fallback cannot disambiguate per-instance codecs (e.g. `vector(1024)` vs. `vector(1536)`), so the dispatch
+* path must reject them at validation time rather than silently bind to the wrong instance.
+*
+* Non-parameterized codec ids (the `voidParamsSchema` case) are always dispatch-safe via codec id alone, so refs-less ParamRefs for those ids are accepted unchanged.
+*
+* The pass runs post-build / pre-execute — the natural location is the SQL runtime's `lower()` step, between any `beforeCompile` rewrites and `encodeParams`. See AC-5 in the codec-registry-unification spec.
+*/
+/**
+* Validate that every parameterized-codec `ParamRef` in `plan` carries `refs`. Throws `RUNTIME.PARAM_REF_REFS_REQUIRED` (a runtime envelope) naming the codec id and the binding label when the invariant is violated. Returns the plan unchanged on success — callers that prefer a side-effecting assertion can ignore the return value.
+*
+* The `registry` is consulted via `descriptorFor(codecId).isParameterized` — `true` whenever the descriptor's `paramsSchema` is not the singleton `voidParamsSchema`.
+*/
+function validateParamRefRefs(plan, registry) {
+	for (const ref of collectOrderedParamRefs(plan)) diagnoseRef(ref, registry);
+}
+function diagnoseRef(ref, registry) {
+	if (!ref.codecId) return;
+	const descriptor = registry.descriptorFor(ref.codecId);
+	if (descriptor === void 0) return;
+	if (!descriptor.isParameterized) return;
+	if (ref.refs) return;
+	throw runtimeError("RUNTIME.PARAM_REF_REFS_REQUIRED", `ParamRef '${ref.name ?? "<anonymous>"}' for parameterized codec '${ref.codecId}' is missing column refs; column-aware dispatch requires { table, column } at the binding site.`, {
+		codecId: ref.codecId,
+		paramName: ref.name
+	});
+}
+
+//#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, SqlCharCodec, SqlCharDescriptor, SqlFloatCodec, SqlFloatDescriptor, SqlIntCodec, SqlIntDescriptor, SqlTextCodec, SqlTextDescriptor, SqlTimestampCodec, SqlTimestampDescriptor, SqlVarcharCodec, SqlVarcharDescriptor, SubqueryExpr, TableSource, UpdateAst, collectOrderedParamRefs, compact, isQueryAst, isWhereExpr, queryAstKinds, sqlCharColumn, sqlCharDecode, sqlCharDescriptor, sqlCharEncode, sqlCharRenderOutputType, sqlFloatColumn, sqlFloatDecode, sqlFloatDescriptor, sqlFloatEncode, sqlIntColumn, sqlIntDecode, sqlIntDescriptor, sqlIntEncode, sqlTextColumn, sqlTextDecode, sqlTextDescriptor, sqlTextEncode, sqlTimestampColumn, sqlTimestampDecode, sqlTimestampDecodeJson, sqlTimestampDescriptor, sqlTimestampEncode, sqlTimestampEncodeJson, sqlTimestampRenderOutputType, sqlVarcharColumn, sqlVarcharDecode, sqlVarcharDescriptor, sqlVarcharEncode, sqlVarcharRenderOutputType, validateParamRefRefs, whereExprKinds };
 //# sourceMappingURL=ast.mjs.map