qubu 0.6.0 → 0.6.1

package/README.md

@@ -0,0 +1,112 @@
+# Qubu
+
+> Build parameterized SQL from simple type declarations and composable values.
+
+Qubu is a functional-first, type-aware SQL builder for TypeScript. Define
+tables once, combine expressions and clauses as ordinary values, and inspect
+the exact SQL and parameters before execution.
+
+Qubu stays close to SQL rather than replacing it with an object model. The type
+system tracks the facts needed to compose a query safely, while the rendered
+statement remains recognizable to anyone who knows SQL.
+
+> [!IMPORTANT]
+> Qubu is pre-alpha. Its public APIs and package structure may change between
+> releases.
+
+## A small query
+
+Declare a table, build a reusable condition, and pass it into a query:
+
+```ts
+import { eq, from, integer, render, select, table, text, where } from "qubu"
+
+const users = table("users", {
+  id: integer(),
+  name: text(),
+})
+
+const byId = where(eq(users.id, 7))
+
+const query = select(
+  {
+    id: users.id,
+    name: users.name,
+  },
+  from(users),
+  byId,
+)
+
+type UserRow = typeof query.row
+// { id: number; name: string }
+
+render(query)
+// {
+//   text: 'SELECT "users"."id" AS "id", "users"."name" AS "name" FROM "users" WHERE ("users"."id" = ?)',
+//   parameters: [7],
+// }
+```
+
+The table declaration supplies the application types, the condition remains a
+value that can be reused, and `7` becomes a bound parameter instead of SQL
+text. The projection determines the inferred result row.
+
+Clauses are independent values. `select()` accepts them in any argument order
+and renders them in canonical SQL order. Writing the final call in SQL order is
+still the preferred style because it is easier to scan.
+
+## Designed to be understood
+
+Qubu favors small declarations and functions that return composable values. A
+query can be assembled or changed one piece at a time, and TypeScript reports
+when those pieces do not fit. Rendering provides the SQL and parameters needed
+to check the result directly.
+
+These properties also help coding agents. A table declaration gives an agent a
+compact description of the data, composable values keep changes local, and the
+type checker and rendered SQL provide concrete feedback. That reduces guessing
+and makes the resulting work easier for a person to review.
+
+Qubu ships [version-matched documentation](docs/index.md) and a
+[Qubu skill](skills/qubu/SKILL.md) that routes agent tasks to the relevant
+guide for the installed package.
+
+## Scope and boundaries
+
+Qubu is for developers who know SQL and want composition and type checking
+without adopting an ORM model. It does not provide relationship loading,
+identity maps, lazy loading, or change tracking.
+
+Qubu constructs and renders queries, and it can pass them through an
+application-supplied adapter. The application continues to own its database
+driver, connections, and database lifecycle. PostgreSQL, SQLite, and MySQL
+differences remain visible through explicit dialect entrypoints.
+
+Optional entrypoints and workspace packages cover schema introspection, source
+generation, snapshots, diffs, migration planning, DDL emission, and migration
+operations. These stages remain separate so applications can inspect and
+approve a change before executing it. See [Supported features](docs/reference/supported-surface.md)
+for the complete package and ownership map.
+
+## Start here
+
+Install Qubu in a TypeScript project:
+
+```bash
+pnpm add qubu
+```
+
+Continue with the documentation for the task at hand:
+
+- [Getting started](docs/getting-started.md) defines a table and renders the
+  first query.
+- [Build a `SELECT`](docs/guides/select/overview.md) covers projections,
+  predicates, joins, grouping, and pagination.
+- [Write mutations](docs/guides/mutations.md) covers typed `INSERT`, `UPDATE`,
+  and `DELETE` statements.
+- [Dialects and execution](docs/dialects-and-execution.md) explains rendering
+  policies and the application-owned adapter boundary.
+- [Schema and migration documentation](docs/schema/tables-and-names.md) starts
+  with table metadata and links through snapshots, diffs, plans, and DDL.
+- [Troubleshooting](docs/troubleshooting.md) starts from common query failures
+  and their repair paths.

package/dist/codegen.d.mts

@@ -1,4 +1,4 @@
-import { St as IntrospectionDiagnostic, dt as IntrospectionResult, i as CatalogClassificationConfidence, p as CatalogDialect, z as CatalogPortableStorageType } from "./types-CTCqtFlS.mjs";
+import { St as IntrospectionDiagnostic, dt as IntrospectionResult, i as CatalogClassificationConfidence, p as CatalogDialect, z as CatalogPortableStorageType } from "./types-BEn0N_al.mjs";
 //#region src/codegen/types.d.ts
 /** TypeScript value types that the controlled source printer can emit. */
 type CodegenApplicationType = "unknown" | "string" | "number" | "boolean" | "bigint" | "Date" | "Uint8Array";

package/dist/codegen.mjs

@@ -1,5 +1,5 @@
 import { l as decodeSchemaSnapshot } from "./canonical-DMvR9yBe.mjs";
-import { t as mapCatalogToSnapshot } from "./snapshot-Xam8-q0j.mjs";
+import { t as mapCatalogToSnapshot } from "./snapshot-DgsOhf_8.mjs";
 //#region src/codegen/source.ts
 const header = `/* Generated by Qubu. Do not edit this machine-owned file. */
 import * as _qubu from 'qubu'

package/dist/{column-r1Y4ivwt.mjs → column-BzN8KFJa.mjs}

@@ -1,4 +1,14 @@
-import { a as assertDialectCapability } from "./json-Db7XRD91.mjs";
+import { a as assertDialectCapability, i as standardJson, o as createDialect } from "./json-Db7XRD91.mjs";
+//#region src/dialects/standard.ts
+/** SQL:2008-style rendering defaults used by the core builder. */
+function standardDialect() {
+	return createDialect({
+		name: "standard-sql",
+		placeholder: () => "?",
+		json: standardJson
+	});
+}
+//#endregion
 //#region src/result.ts
 const resultValueMetadata = Symbol("qubu.result-value-metadata");
 function resultValue(type, decoder) {
@@ -286,6 +296,33 @@ function assertSchemaDialectSupport(diagnostics) {
 	if (diagnostics.length > 0) throw new SchemaMetadataValidationError(diagnostics);
 }
 //#endregion
+//#region src/core/primitives/parameter.ts
+function parameter(_value) {
+	return fragment((context) => context.parameter(_value));
+}
+//#endregion
+//#region src/expressions/value.ts
+function value(input) {
+	const expression = makeSchemaExpression("value", (context) => context.render(parameter(input)));
+	return Object.freeze({
+		...expression,
+		value: input
+	});
+}
+/** Bind a value while declaring its SQL semantic domain. */
+function typedValue(input) {
+	return value(input);
+}
+function isExpressionValue(valueToCheck) {
+	return typeof valueToCheck === "object" && valueToCheck !== null && "expressionKind" in valueToCheck && "render" in valueToCheck && typeof valueToCheck.render === "function";
+}
+function isValueExpression(valueToCheck) {
+	return isExpressionValue(valueToCheck) && valueToCheck.expressionKind === "value" && "value" in valueToCheck;
+}
+function asValue(input) {
+	return isExpressionValue(input) ? input : value(input);
+}
+//#endregion
 //#region src/core/primitives/identifier.ts
 function identifier(name) {
 	return fragment((context) => context.append(context.dialect.quoteIdentifier(name)));
@@ -324,4 +361,4 @@ function expressionFragment(expression) {
 	return fragment((context) => context.render(expression));
 }
 //#endregion
-export { dateResultDecoder as A, fragment as C, ResultDecodingError as D, sequence as E, resultValueOf as F, timestampResultDecoder as I, jsonTextResultDecoder as M, resultShapeValue as N, booleanResultDecoder as O, resultValue as P, withDialectCapability as S, parenthesize as T, isSchemaExpression as _, qualifiedIdentifier as a, markExpressionCategory as b, dialectMismatchDiagnostic as c, isValidSchemaObjectName as d, materializeSchemaObjectIdentity as f, isExpression as g, snakeCaseIdentifier as h, identifier as i, decodeResultRow as j, createResultShape as k, freezeSchemaMetadata as l, resolveSqlNames as m, expressionFragment as n, SchemaMetadataValidationError as o, materializeSchemaObjectRecord as p, isColumnReference as r, assertSchemaDialectSupport as s, createColumnReference as t, generatedSchemaObjectName as u, makeExpression as v, isFragment as w, markSchemaExpression as x, makeSchemaExpression as y };
+export { parenthesize as A, resultValueOf as B, makeExpression as C, withDialectCapability as D, markSchemaExpression as E, dateResultDecoder as F, standardDialect as H, decodeResultRow as I, jsonTextResultDecoder as L, ResultDecodingError as M, booleanResultDecoder as N, fragment as O, createResultShape as P, resultShapeValue as R, isSchemaExpression as S, markExpressionCategory as T, timestampResultDecoder as V, materializeSchemaObjectIdentity as _, qualifiedIdentifier as a, snakeCaseIdentifier as b, typedValue as c, SchemaMetadataValidationError as d, assertSchemaDialectSupport as f, isValidSchemaObjectName as g, generatedSchemaObjectName as h, identifier as i, sequence as j, isFragment as k, value as l, freezeSchemaMetadata as m, expressionFragment as n, asValue as o, dialectMismatchDiagnostic as p, isColumnReference as r, isValueExpression as s, createColumnReference as t, parameter as u, materializeSchemaObjectRecord as v, makeSchemaExpression as w, isExpression as x, resolveSqlNames as y, resultValue as z };

package/dist/{column-Da37jYSD.mjs → column-CFvSbil0.mjs}

@@ -1,4 +1,4 @@
-import { P as resultValue, _ as isSchemaExpression, l as freezeSchemaMetadata } from "./column-r1Y4ivwt.mjs";
+import { S as isSchemaExpression, m as freezeSchemaMetadata, z as resultValue } from "./column-BzN8KFJa.mjs";
 //#region src/schema/column-behavior.ts
 /** A column behavior error with a stable code and optional property path. */
 var ColumnBehaviorError = class extends TypeError {

package/dist/{complete-types-CY0KbzNw.d.mts → complete-types-CNMWBWap.d.mts}

@@ -1,4 +1,4 @@
-import { A as SnapshotStorage, D as SnapshotLiteral, O as SnapshotNamingPolicy, T as SnapshotJsonValue, b as SnapshotGeneratedColumn, d as SnapshotDefault, f as SnapshotDiagnostic, g as SnapshotExpression, h as SnapshotDialectExtension, i as SchemaSnapshotInput, m as SnapshotDialect } from "./types-C0VkiwpR.mjs";
+import { A as SnapshotStorage, D as SnapshotLiteral, O as SnapshotNamingPolicy, T as SnapshotJsonValue, b as SnapshotGeneratedColumn, d as SnapshotDefault, f as SnapshotDiagnostic, g as SnapshotExpression, h as SnapshotDialectExtension, i as SchemaSnapshotInput, m as SnapshotDialect } from "./types-DUe6eeI0.mjs";
 //#region src/snapshot/complete-types.d.ts
 /** The stable envelope tag shared by Snapshot v1 and the complete model. */
 declare const completeSchemaSnapshotFormat: "qubu-schema";

package/dist/{constraints-YGyNPQ_z.mjs → constraints-DM_tarXc.mjs}

@@ -1,5 +1,5 @@
-import { c as dialectMismatchDiagnostic, l as freezeSchemaMetadata, r as isColumnReference } from "./column-r1Y4ivwt.mjs";
-import { p as unsafeSchemaSql } from "./registry-BRcUuazJ.mjs";
+import { m as freezeSchemaMetadata, p as dialectMismatchDiagnostic, r as isColumnReference } from "./column-BzN8KFJa.mjs";
+import { c as unsafeSchemaSql } from "./expressions-BCjc08zw.mjs";
 //#region src/schema/indexes.ts
 /**
 * Validate portable and dialect-owned index facts for one target adapter. Unsupported features are

package/dist/core.d.mts

@@ -1,4 +1,4 @@
-import { $ as PaginationKind, $l as AggregateMeta, $u as SqlNumericLike, Au as RequiresOuterMetadataOf, B as CastTarget, Bl as withDialectCapability, Bu as isFragment, Ca as SelectClause, Cu as ProvidesOuterSourceMeta, Du as RenderFunction, Eu as RenderContext, Fu as SqlTypeOf, G as DialectJson, Ga as typedCall, Gu as SqlBinary, H as DialectCapability, Hu as sequence, Iu as SubqueryMeta, J as DialectRowLocking, Ju as SqlDecimal, K as DialectOptions, Ku as SqlBoolean, Ll as isExpression, Lu as VisibleDependenciesOf, Mu as RequiresOuterSourceMeta, No as typedCast, Nu as RequiresSourceMeta, Ol as Expression, Ou as RequiresCapabilityMeta, Pu as ResultMeta, Q as NamedCastTarget, Ql as AggregateDependenciesOf, Qu as SqlJson, Rl as makeExpression, Ru as WindowMeta, Sa as ClausePlacement, Su as ProvidesOuterOf, Tl as expressionFragment, Tu as QueryCardinality, U as DialectCastTypes, Uu as AnySqlType, V as Dialect, Vu as parenthesize, W as DialectExplain, Wu as SqlBigInt, X as ExplainRenderOptions, Xu as SqlEqualityCompatible, Y as ExplainFormat, Yu as SqlEqualityComparable, Z as JsonScalarKind, Zu as SqlInteger, _l as RenderedQuery, _u as MetadataOf, ad as SqlTimestamp, at as SchemaLiteralRenderer, au as DependenciesOf, bu as NullableSourcesOf, cd as SqlUuid, ct as resolveCastTarget, cu as FragmentMeta, du as GroupingMeta, ed as SqlOrderCompatible, et as PaginationPart, eu as AnyFragment, fu as HasAggregate, gl as RenderOptions, gu as InheritedMetadataOf, hl as RenderCapabilityValidation, hu as InheritedMetadata, id as SqlTextLike, it as RowLockWaitPolicy, iu as CardinalityOf, ju as RequiresOuterOf, ko as typedValue, ku as RequiresOf, lu as GroupingDependenciesOf, mu as HasWindow, nd as SqlSemanticType, nt as PortableCastType, nu as CapabilityMetadataOf, od as SqlTypeSatisfies, ot as assertDialectCapability, ou as ExpressionMeta, pu as HasSubquery, q as DialectPagination, qu as SqlDate, rd as SqlText, rt as RowLockMode, ru as CardinalityMeta, sd as SqlUnknown, st as createDialect, su as Fragment, td as SqlOrderable, tt as PortableCastTarget, tu as CapabilitiesOf, uu as GroupingKeysOf, vl as render, vu as NullabilityOf, wu as ProvidesSourceMeta, xu as OutputOf, yu as NullableSourceMeta, zl as markExpressionCategory, zu as fragment } from "./types-C0VkiwpR.mjs";
+import { $ as PaginationKind, $u as SqlDecimal, Al as expressionFragment, Au as QueryCardinality, B as CastTarget, Bu as SqlTypeOf, Cl as render, Cu as NullabilityOf, Da as ClausePlacement, Du as ProvidesOuterOf, Eu as OutputOf, Fu as RequiresOuterMetadataOf, G as DialectJson, Gl as withDialectCapability, Gu as isFragment, H as DialectCapability, Hl as isExpression, Hu as VisibleDependenciesOf, Iu as RequiresOuterOf, J as DialectRowLocking, Ju as AnySqlType, K as DialectOptions, Ku as parenthesize, Lu as RequiresOuterSourceMeta, Mu as RenderFunction, Nl as Expression, Nu as RequiresCapabilityMeta, Oa as SelectClause, Ou as ProvidesOuterSourceMeta, Po as typedValue, Pu as RequiresOf, Q as NamedCastTarget, Qu as SqlDate, Ro as typedCast, Ru as RequiresSourceMeta, Sl as RenderedQuery, Su as MetadataOf, Tu as NullableSourcesOf, U as DialectCastTypes, Ul as makeExpression, Uu as WindowMeta, V as Dialect, Vu as SubqueryMeta, W as DialectExplain, Wl as markExpressionCategory, Wu as fragment, X as ExplainRenderOptions, Xa as typedCall, Xu as SqlBinary, Y as ExplainFormat, Yu as SqlBigInt, Z as JsonScalarKind, Zu as SqlBoolean, _u as HasAggregate, ad as SqlOrderCompatible, at as SchemaLiteralRenderer, au as AnyFragment, bl as RenderCapabilityValidation, bu as InheritedMetadata, cd as SqlText, ct as resolveCastTarget, cu as CardinalityMeta, dd as SqlTypeSatisfies, du as ExpressionMeta, ed as SqlEqualityComparable, et as PaginationPart, fd as SqlUnknown, fu as Fragment, gu as GroupingMeta, hu as GroupingKeysOf, id as SqlNumericLike, it as RowLockWaitPolicy, iu as AggregateMeta, ju as RenderContext, ku as ProvidesSourceMeta, ld as SqlTextLike, lu as CardinalityOf, mu as GroupingDependenciesOf, nd as SqlInteger, nt as PortableCastType, od as SqlOrderable, ot as assertDialectCapability, ou as CapabilitiesOf, pd as SqlUuid, pu as FragmentMeta, q as DialectPagination, qu as sequence, rd as SqlJson, rt as RowLockMode, ru as AggregateDependenciesOf, sd as SqlSemanticType, st as createDialect, su as CapabilityMetadataOf, td as SqlEqualityCompatible, tt as PortableCastTarget, ud as SqlTimestamp, uu as DependenciesOf, vu as HasSubquery, wu as NullableSourceMeta, xl as RenderOptions, xu as InheritedMetadataOf, yu as HasWindow, zu as ResultMeta } from "./types-DUe6eeI0.mjs";
 //#region src/core/primitives/compose.d.ts
 declare function commaSeparated<const TParts extends readonly AnyFragment[]>(parts: TParts): Fragment<InheritedMetadata<TParts[number]>>;
 declare function keyword<TPart extends AnyFragment | undefined>(value: string, part?: TPart): Fragment<TPart extends AnyFragment ? InheritedMetadata<TPart> : never>;

package/dist/core.mjs

@@ -1,7 +1,6 @@
 import { a as assertDialectCapability, o as createDialect, s as resolveCastTarget } from "./json-Db7XRD91.mjs";
-import { a as routineName, c as render, i as typedCall, s as typedCast, t as createClause } from "./types-BIJsj2fJ.mjs";
-import { C as fragment, E as sequence, S as withDialectCapability, T as parenthesize, a as qualifiedIdentifier, b as markExpressionCategory, g as isExpression, i as identifier, n as expressionFragment, v as makeExpression, w as isFragment } from "./column-r1Y4ivwt.mjs";
-import { a as parameter, r as typedValue } from "./value-D14I_XgL.mjs";
+import { A as parenthesize, C as makeExpression, D as withDialectCapability, O as fragment, T as markExpressionCategory, a as qualifiedIdentifier, c as typedValue, i as identifier, j as sequence, k as isFragment, n as expressionFragment, u as parameter, x as isExpression } from "./column-BzN8KFJa.mjs";
+import { a as routineName, c as render, i as typedCall, s as typedCast, t as createClause } from "./types-BLNRatG_.mjs";
 //#region src/core/primitives/compose.ts
 function commaSeparated(parts) {
 	return sequence(parts, ", ");

package/dist/diagnostics-I9vVtXkc.mjs

@@ -0,0 +1,40 @@
+//#region src/introspection/diagnostics.ts
+/**
+* Create one immutable diagnostic without interpreting catalog text or copying driver error details
+* into the structured fields.
+*/
+function createIntrospectionDiagnostic(diagnostic) {
+	return freezeDiagnostic(diagnostic);
+}
+/** Return whether a diagnostic list prevents strict introspection output. */
+function hasIntrospectionErrors(diagnostics) {
+	return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+/** Error raised by a throwing introspection operation after collecting findings. */
+var IntrospectionError = class extends Error {
+	name = "IntrospectionError";
+	diagnostics;
+	issues;
+	constructor(diagnostics) {
+		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => freezeDiagnostic(diagnostic)));
+		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
+		this.diagnostics = frozenDiagnostics;
+		this.issues = frozenDiagnostics;
+	}
+};
+function freezeDiagnostic(diagnostic) {
+	return Object.freeze({
+		...diagnostic,
+		path: Object.freeze([...diagnostic.path]),
+		physicalReference: diagnostic.physicalReference ? freezeReference(diagnostic.physicalReference) : void 0,
+		relatedReferences: diagnostic.relatedReferences ? Object.freeze(diagnostic.relatedReferences.map((reference) => freezeReference(reference))) : void 0
+	});
+}
+function freezeReference(reference) {
+	return Object.freeze({
+		...reference,
+		catalog: reference.catalog ? Object.freeze({ ...reference.catalog }) : void 0
+	});
+}
+//#endregion
+export { createIntrospectionDiagnostic as n, hasIntrospectionErrors as r, IntrospectionError as t };

package/dist/diff.d.mts

@@ -1,5 +1,5 @@
-import { T as SnapshotJsonValue, m as SnapshotDialect, n as SchemaSnapshot } from "./types-C0VkiwpR.mjs";
-import { S as CompleteSnapshotObjectKind, t as CompleteSchemaSnapshot } from "./complete-types-CY0KbzNw.mjs";
+import { T as SnapshotJsonValue, m as SnapshotDialect, n as SchemaSnapshot } from "./types-DUe6eeI0.mjs";
+import { S as CompleteSnapshotObjectKind, t as CompleteSchemaSnapshot } from "./complete-types-CNMWBWap.mjs";
 //#region src/diff/types.d.ts
 /** Object families understood by the snapshot diff engine. */
 type SnapshotDiffObjectKind = CompleteSnapshotObjectKind;

package/dist/expressions-BCjc08zw.mjs

@@ -0,0 +1,129 @@
+import { E as markSchemaExpression, H as standardDialect, S as isSchemaExpression, r as isColumnReference, s as isValueExpression, w as makeSchemaExpression } from "./column-BzN8KFJa.mjs";
+//#region src/schema/expressions.ts
+/** Error raised before a schema expression can become persisted SQL. */
+var SchemaExpressionError = class extends TypeError {
+	code;
+	mode;
+	constructor(code, message, mode) {
+		super(message);
+		this.name = "SchemaExpressionError";
+		this.code = code;
+		this.mode = mode;
+	}
+};
+/**
+* Normalize only line endings. Whitespace, quoting, and every other byte of a raw schema expression
+* remain under the extension author's control.
+*/
+function normalizeSchemaSql(sql) {
+	return sql.replace(/\r\n?/g, "\n");
+}
+function schemaExpression(expression) {
+	return markSchemaExpression(expression);
+}
+/**
+* Define an extension with the restricted schema context. This is the typed alternative to
+* {@link unsafeSchemaSql} for deterministic custom syntax.
+*/
+function defineSchemaExpression(kind, render) {
+	return makeSchemaExpression(kind, (context) => render(context));
+}
+function unsafeSchemaSql(dialectOrOptions, sql) {
+	const dialect = typeof dialectOrOptions === "string" ? dialectOrOptions : dialectOrOptions.dialect;
+	const source = typeof dialectOrOptions === "string" ? sql : dialectOrOptions.sql;
+	if (!dialect) throw new TypeError("unsafeSchemaSql() requires a dialect tag");
+	if (source === void 0) throw new TypeError("unsafeSchemaSql() requires SQL text");
+	const normalized = normalizeSchemaSql(source);
+	const expression = makeSchemaExpression("unsafe", (context) => context.append(normalized));
+	return Object.freeze({
+		...expression,
+		schemaSqlDialect: dialect,
+		schemaSql: normalized
+	});
+}
+/** Identify a dialect-tagged raw schema expression. */
+function isUnsafeSchemaSql(value) {
+	return isSchemaExpression(value) && value.expressionKind === "unsafe" && typeof value.schemaSqlDialect === "string" && typeof value.schemaSql === "string";
+}
+function renderSchemaExpression(expression, optionsOrMode, dialectOption) {
+	const options = typeof optionsOrMode === "string" ? {
+		mode: optionsOrMode,
+		dialect: dialectOption
+	} : optionsOrMode;
+	const dialect = options.dialect ?? standardDialect();
+	if (!isSchemaExpression(expression)) throw new SchemaExpressionError("not-deterministic", "Only branded deterministic expressions can be rendered as schema SQL", options.mode);
+	assertSupportedExpression(expression, options.mode);
+	let text = "";
+	const context = {
+		dialect,
+		projectionMode: "result",
+		schemaMode: options.mode,
+		append(value) {
+			text += value;
+		},
+		parameter() {
+			throw new SchemaExpressionError("parameter", "Schema expressions cannot render query parameters", options.mode);
+		},
+		literal(value) {
+			text += renderSchemaLiteral(dialect, value, options.mode);
+		},
+		renderColumnReference(columnName) {
+			if (options.mode === "default") throw new SchemaExpressionError("column-not-allowed", "Default expressions cannot reference table columns", options.mode);
+			text += dialect.quoteIdentifier(columnName);
+		},
+		render(part) {
+			renderSchemaPart(context, part, options.mode);
+		},
+		renderRelation() {
+			throw new SchemaExpressionError("unsupported-expression", "Schema expressions cannot contain subqueries", options.mode);
+		}
+	};
+	renderSchemaPart(context, expression, options.mode);
+	return Object.freeze({
+		text,
+		parameters: Object.freeze([])
+	});
+}
+/** Convenience form for callers that only need the SQL text. */
+function renderSchemaSql(expression, options) {
+	return renderSchemaExpression(expression, options).text;
+}
+function renderSchemaPart(context, part, mode) {
+	if (isValueExpression(part)) {
+		context.literal(part.value);
+		return;
+	}
+	if (isColumnReference(part)) {
+		context.renderColumnReference(part.columnName);
+		return;
+	}
+	if (isUnsafeSchemaSql(part)) {
+		if (part.schemaSqlDialect !== context.dialect.name) throw new SchemaExpressionError("dialect-mismatch", `Schema SQL is tagged for "${part.schemaSqlDialect}" but rendered for "${context.dialect.name}"`, mode);
+		context.append(part.schemaSql);
+		return;
+	}
+	if (!isSchemaExpression(part)) throw new SchemaExpressionError("not-deterministic", "Schema expressions may only compose branded expressions, columns, and literals", mode);
+	assertSupportedExpression(part, mode);
+	part.render(context);
+}
+function assertSupportedExpression(expression, mode) {
+	if (expression.expressionKind === "subquery" || expression.expressionCategory) throw new SchemaExpressionError("unsupported-expression", "Aggregates, windows, and subqueries are not valid schema expressions", mode);
+}
+function renderSchemaLiteral(dialect, value, mode) {
+	if (dialect.renderSchemaLiteral) {
+		const rendered = dialect.renderSchemaLiteral(value);
+		if (typeof rendered !== "string" || rendered.includes("?")) throw new SchemaExpressionError("invalid-literal", "A schema literal renderer must return parameter-free SQL text", mode);
+		return rendered;
+	}
+	if (value === null) return "NULL";
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
+	if (typeof value === "bigint") return String(value);
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new SchemaExpressionError("unsupported-value", "Schema literals require finite numbers", mode);
+		return Object.is(value, -0) ? "0" : String(value);
+	}
+	throw new SchemaExpressionError("unsupported-value", `Unsupported schema literal type: ${value === void 0 ? "undefined" : typeof value}`, mode);
+}
+//#endregion
+export { renderSchemaExpression as a, unsafeSchemaSql as c, normalizeSchemaSql as i, defineSchemaExpression as n, renderSchemaSql as o, isUnsafeSchemaSql as r, schemaExpression as s, SchemaExpressionError as t };

package/dist/{index-B2rZf3-2.d.mts → index-CGui70hi.d.mts}

@@ -1,5 +1,5 @@
-import { f as SnapshotDiagnostic } from "./types-C0VkiwpR.mjs";
-import { n as CompleteSchemaSnapshotInput, t as CompleteSchemaSnapshot, u as CompleteSnapshotDecodeResult } from "./complete-types-CY0KbzNw.mjs";
+import { f as SnapshotDiagnostic } from "./types-DUe6eeI0.mjs";
+import { n as CompleteSchemaSnapshotInput, t as CompleteSchemaSnapshot, u as CompleteSnapshotDecodeResult } from "./complete-types-CNMWBWap.mjs";
 //#region src/snapshot/complete.d.ts
 /** Error raised by throwing APIs after collecting strict v2 diagnostics. */
 declare class CompleteSnapshotValidationError extends TypeError {

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as PaginationKind, $a as SqlTag, $c as QubuStreamingTransaction, $i as SourceIndexesRecord, $l as AggregateMeta, $n as WithClause, $o as ColumnStorageDialectOf, $s as ResolvedColumnBehavior, $t as nullsLast, $u as SqlNumericLike, Aa as jsonBoolean, Ac as ExplainReadOptions, Ai as catalogCheck, Al as ExpressionNullability, An as MutationReturningClause, Ao as value, Ar as SchemaExpressionErrorCode, As as numeric, At as SourceSqlTypeMap, Au as RequiresOuterMetadataOf, B as CastTarget, Ba as concat, Bc as HookQueryOperation, Bi as AliasedSource, Bn as select, Bo as ColumnHasDefault, Bs as DefaultDescriptor, Bt as TableDefinitions, Ca as SelectClause, Cc as ExecutionOptions, Ci as SourceConstraintsRecord, Cl as ColumnDependency, Cn as update, Co as isTrue, Cr as SelectionSqlTypes, Cs as date, Ct as SourceColumns, Cu as ProvidesOuterSourceMeta, Da as multiply, Dc as ExplainOptions, Di as UniqueConstraint, Dl as AnySchemaExpression, Dn as MutationQuery, Ds as nativeColumn, Dt as SourceKind, Du as RenderFunction, Ea as modulo, Ec as ExplainMutationOptions, Ei as TableLike, El as AnyExpression, En as MutationKind, Er as SchemaDialectHooks, Es as json, Et as SourceIdentity, Eu as RenderContext, Fa as denseRank, Fc as HookMetadata, Fi as references, Fl as SchemaExpression, Fn as ReturningClause, Fo as ColumnDefaultOf, Fr as UnsafeSchemaSqlExpression, Fs as CanonicalLiteral, Fu as SqlTypeOf, G as DialectJson, Gc as QubuClient, Gi as alias, Gl as ResultDecodingError, Gn as MissingScope, Gr as SchemaNamingPolicy, Gs as GeneratedColumnDescriptor, Gt as TableRow, Gu as SqlBinary, H as DialectCapability, Ha as upper, Hc as HookSuccessOutcome, Hi as LateralSource, Hl as ResultDecodeContext, Hn as AvailableScope, Ho as ColumnIdentityOf, Hr as unsafeSchemaSql, Hs as ExpressionGeneratedColumnDescriptor, Ht as TableInsertInput, Ia as over, Ic as HookMetadataValue, Ii as unique, Il as SchemaExpressionBrand, In as ReturningRow, Io as ColumnDefinition, Is as ColumnBehaviorError, Iu as SubqueryMeta, J as DialectRowLocking, Ja as countDistinct, Jc as QubuExplainableTransactionalClient, Ji as IndexOptions, Jl as booleanResultDecoder, Jn as ScopeValidation, Jo as ColumnOutput, Jr as SchemaTableNames, Js as IdentityDescriptor, Jt as table, Ju as SqlDecimal, K as DialectOptions, Ka as avg, Kc as QubuExplainableClient, Ki as lateral, Kl as ResultField, Kn as RequiredOuterScope, Ko as ColumnOnUpdateOf, Kr as SchemaOptions, Ks as GeneratedColumnMode, Kt as TableSqlTypes, Ku as SqlBoolean, La as rank, Lc as HookOperation, Li as uniqueConstraint, Ln as ReturningSqlTypes, Lo as ColumnDefinitionConfig, Ls as ColumnBehaviorErrorCode, Lt as AnyTable, Lu as VisibleDependenciesOf, Ma as jsonNumber, Mc as ExplainResult, Mi as check, Ml as ExpressionRequires, Mn as MutationScopeValidation, Mo as cast, Mr as SchemaExpressionMode, Ms as text, Mu as RequiresOuterSourceMeta, Na as jsonPath, Nc as ExplainableQueryAdapter, Ni as foreignKey, Nl as ExpressionSqlType, Nn as MutationSqlTypes, Nr as SchemaRenderContext, Ns as timestamp, Nu as RequiresSourceMeta, Oa as subtract, Oc as ExplainOptionsFor, Oi as UniqueConstraintOptions, Ol as Expression, On as MutationQueryConfig, Oo as asValue, Or as RenderedSchemaExpression, Os as nativeStorage, Ot as SourceProvision, Ou as RequiresCapabilityMeta, Pa as jsonText, Pc as HookErrorOutcome, Pi as primaryKey, Pl as ExpressionWithOutput, Pn as allowAll, Po as ColumnCodec, Pr as SchemaRenderOptions, Ps as uuid, Pu as ResultMeta, Q as NamedCastTarget, Qa as SqlFragment, Qc as QubuStreamingExplainableClient, Qi as SourceIndex, Ql as AggregateDependenciesOf, Qn as RecursiveCteSource, Qs as MysqlIdentityExtension, Qt as nullsFirst, Qu as SqlJson, Ra as rowNumber, Rc as HookOperationKind, Rn as returning, Rs as ColumnDefault, Rt as Table, Ru as WindowMeta, Sa as ClausePlacement, Sc as DriverValueEncoder, Si as SourceConstraint, Sl as QueryValidationIssue, Sn as UpdateAssignments, So as isNull, Sr as SelectionOutput, St as Source, Su as ProvidesOuterOf, Ta as divide, Tc as ExecutionResult, Ti as SqliteConstraintExtension, Tn as MutationClause, Tr as SchemaDialect, Ts as integer, Tt as SourceConstraints, Tu as QueryCardinality, U as DialectCastTypes, Ua as call, Uc as HookTransactionOperation, Ui as QueryAliasIdentity, Ul as ResultDecoder, Un as ClauseScope, Uo as ColumnInsertInput, Ur as Schema, Us as ExternalDefaultDescriptor, Uu as AnySqlType, V as Dialect, Va as lower, Vc as HookStreamEnd, Vi as LateralIdentity, Vl as DecodableResultType, Vn as AvailableOuterScope, Vo as ColumnHasRuntimeDefault, Vs as ExpressionDefaultDescriptor, Vt as TableIdentity, W as DialectExplain, Wa as schemaCall, Wc as OperationEndHook, Wi as QuerySource, Wl as ResultDecoders, Wn as GroupingValidation, Wo as ColumnIsGenerated, Wr as SchemaDiagnostic, Ws as ExternalGeneratedColumnDescriptor, Wu as SqlBigInt, X as ExplainRenderOptions, Xa as min, Xc as QubuOptions, Xi as MysqlIndexExtension, Xl as jsonTextResultDecoder, Xn as SelectQuery, Xo as ColumnStorage, Xr as SchemaTableRegistry, Xs as IdentityGeneration, Xt as asc, Xu as SqlEqualityCompatible, Y as ExplainFormat, Ya as max, Yc as QubuHooks, Yi as IndexTerm, Yl as dateResultDecoder, Yn as SelectCardinality, Yo as ColumnSqlType, Yr as SchemaTableRecord, Ys as IdentityDialectExtension, Yt as OrderTerm, Yu as SqlEqualityComparable, Z as JsonScalarKind, Za as sum, Zc as QubuStreamingClient, Zi as PostgresIndexExtension, Zl as timestampResultDecoder, Zn as CteSource, Zo as ColumnStorageDeclarationOf, Zs as LiteralDefaultDescriptor, Zt as desc, Zu as SqlInteger, _a as fetchNext, _i as KeyConstraint, _l as RenderedQuery, _o as notLike, _r as FromScope, _t as AnySource, _u as MetadataOf, aa as and, ac as generatedColumn, ad as SqlTimestamp, ai as CheckConstraint, al as StreamableQuery, an as InsertSource, ao as notExists, ar as except, at as SchemaLiteralRenderer, au as DependenciesOf, ba as distinct, bi as PostgresConstraintExtension, bl as QueryValidationError, bo as notIn, br as Selection, bs as boolean, bt as ProvidedSourceIdentity, bu as NullableSourcesOf, ca as Omit, cc as SchemaDialectExtension, cd as SqlUuid, ci as ConstraintOptions, cl as TransactionOptions, cn as insertInto, co as eq, cr as unionAll, cu as FragmentMeta, da as omit, di as FieldLikeOptions, dl as executeRows, do as isDistinctFrom, dr as innerJoin, dt as QueryConfig, du as GroupingMeta, ea as SqliteIndexExtension, ec as SchemaLiteralValue, ed as SqlOrderCompatible, ei as schema, el as QubuStreamingTransactionalClient, en as order, eo as TypedSqlTag, er as cte, es as ColumnStorageKindOf, et as PaginationPart, eu as AnyFragment, fa as where, fc as SchemaObjectIdentity, fi as ForeignKeyConstraint, fl as explain, fo as isNotDistinctFrom, fr as leftJoin, ft as QueryKind, fu as HasAggregate, ga as fetchFirst, gi as ForeignKeyTargetInput, gl as RenderOptions, go as ne, gr as FromClause, gt as Row, gu as InheritedMetadataOf, ha as rowLock, hi as ForeignKeyTarget, ho as lte, hr as groupBy, ht as QueryWithRow, hu as InheritedMetadata, ia as DeclaredColumnNullability, ic as externalGeneratedColumn, id as SqlTextLike, ii as CatalogCheckSql, il as QueryExecutor, in as InsertSelectSource, io as inQuery, ir as SetQuery, is as ColumnUpdateInput, it as RowLockWaitPolicy, iu as CardinalityOf, ja as jsonExists, jc as ExplainRequest, ji as catalogForeignKey, jl as ExpressionOutput, jn as MutationRow, jo as mapResult, jr as SchemaExpressionInput, js as portableStorage, ju as RequiresOuterOf, ka as JsonPath, kc as ExplainPlanRow, ki as UniqueNullSemantics, kl as ExpressionKind, kn as MutationReturning, ks as nullable, kt as SourceRow, ku as RequiresOf, la as OmittableSelectClause, lc as SchemaDialectName, li as ConstraintTiming, ll as TransactionalQueryAdapter, ln as insertSelect, lo as gt, lr as crossJoin, ls as PortableColumnStorage, lt as AnyQuery, lu as GroupingDependenciesOf, ma as RowLockOptions, mi as ForeignKeyOptions, ml as stream, mo as lt, mr as rightJoin, mt as QuerySqlTypeMap, mu as HasWindow, na as index, nd as SqlSemanticType, ni as AnyKeyColumn, nl as QubuTransactionalClient, nn as deleteFrom, no as caseWhen, nr as withCte, nt as PortableCastType, nu as CapabilityMetadataOf, oa as not, oc as identityColumn, od as SqlTypeSatisfies, oi as CheckConstraintOptions, ol as StreamingQueryAdapter, on as ValuesSource, oo as scalar, or as intersect, os as NativeColumnStorage, ou as ExpressionMeta, pa as RowLockClause, pc as SchemaObjectNameOptions, pi as ForeignKeyMatch, pl as qubu, po as like, pr as naturalJoin, pt as QueryRow, pu as HasSubquery, q as DialectPagination, qa as count, qc as QubuExplainableStreamingTransactionalClient, qi as IndexDialectExtension, ql as ResultShape, qn as RequiredScope, qo as ColumnOptions, qr as SchemaTableEntry, qs as GeneratedDescriptor, qt as TableUpdateInput, qu as SqlDate, rc as externalDefault, rd as SqlText, ri as CatalogCheckExpression, rl as QueryAdapter, rn as DefaultValuesSource, ro as exists, rr as SetOperator, rs as ColumnStorageTypeOf, rt as RowLockMode, ru as CardinalityMeta, sa as or, sd as SqlUnknown, si as ConstraintDialectExtension, sl as StreamingTransactionalQueryAdapter, sn as defaultValues, sr as union, su as Fragment, ta as TableIndex, tc as SqliteIdentityExtension, td as SqlOrderable, tl as QubuTransaction, tn as orderBy, to as sql, tr as recursiveCte, ts as ColumnStorageOf, tt as PortableCastTarget, tu as CapabilitiesOf, ua as SelectPart, uc as SchemaMetadataDiagnostic, ui as FieldLike, ul as execute, un as values, uo as gte, ur as fullJoin, ut as Query, uu as GroupingKeysOf, va as offset, vi as KeyConstraintOptions, vl as render, vo as between, vr as FromSource, vs as bigint, vu as NullabilityOf, wa as add, wc as ExecutionRequest, wi as SourceLike, wl as ColumnReference, wn as AllowAllClause, wr as all, wt as SourceConfig, wu as ProvidesSourceMeta, xa as AnySelectClause, xc as AdapterExecutionResult, xi as ReferentialAction, xl as QueryValidationErrorCode, xn as UpdateAssignmentValue, xo as isNotNull, xr as SelectionObject, xs as column, xt as ProvidedSourceRow, xu as OutputOf, ya as having, yi as MysqlConstraintExtension, yl as QueryTypeValidation, yo as inList, yr as from, ys as binary, yu as NullableSourceMeta, za as coalesce, zc as HookOutcome, zi as AliasIdentity, zn as correlate, zo as ColumnGeneratedOf, zs as ColumnDefaultInput, zt as TableColumns } from "./types-C0VkiwpR.mjs";
-export { type AdapterExecutionResult, type AggregateDependenciesOf, type AggregateMeta, type AliasIdentity, type AliasedSource, type AllowAllClause, type AnyExpression, type AnyFragment, type AnyKeyColumn, type AnyQuery, type AnySchemaExpression, type AnySelectClause, type AnySource, type AnySqlType, type AnyTable, type AvailableOuterScope, type AvailableScope, type CanonicalLiteral, type CapabilitiesOf, type CapabilityMetadataOf, type CardinalityMeta, type CardinalityOf, type CastTarget, type CatalogCheckExpression, type CatalogCheckSql, type CheckConstraint, type CheckConstraintOptions, type ClausePlacement, type ClauseScope, type ColumnBehaviorError, type ColumnBehaviorErrorCode, type ColumnCodec, type ColumnDefault, type ColumnDefaultInput, type ColumnDefaultOf, type ColumnDefinition, type ColumnDefinitionConfig, type ColumnDependency, type ColumnGeneratedOf, type ColumnHasDefault, type ColumnHasRuntimeDefault, type ColumnIdentityOf, type ColumnInsertInput, type ColumnIsGenerated, type ColumnOnUpdateOf, type ColumnOptions, type ColumnOutput, type ColumnReference, type ColumnSqlType, type ColumnStorage, type ColumnStorageDeclarationOf, type ColumnStorageDialectOf, type ColumnStorageKindOf, type ColumnStorageOf, type ColumnStorageTypeOf, type ColumnUpdateInput, type ConstraintDialectExtension, type ConstraintOptions, type ConstraintTiming, type CteSource, type DeclaredColumnNullability, type DecodableResultType, type DefaultDescriptor, type DefaultValuesSource, type DependenciesOf, type Dialect, type DialectCapability, type DialectCastTypes, type DialectExplain, type DialectJson, type DialectOptions, type DialectPagination, type DialectRowLocking, type DriverValueEncoder, type ExecutionOptions, type ExecutionRequest, type ExecutionResult, type ExplainFormat, type ExplainMutationOptions, type ExplainOptions, type ExplainOptionsFor, type ExplainPlanRow, type ExplainReadOptions, type ExplainRenderOptions, type ExplainRequest, type ExplainResult, type ExplainableQueryAdapter, type Expression, type ExpressionDefaultDescriptor, type ExpressionGeneratedColumnDescriptor, type ExpressionKind, type ExpressionMeta, type ExpressionNullability, type ExpressionOutput, type ExpressionRequires, type ExpressionSqlType, type ExpressionWithOutput, type ExternalDefaultDescriptor, type ExternalGeneratedColumnDescriptor, type FieldLike, type FieldLikeOptions, type ForeignKeyConstraint, type ForeignKeyMatch, type ForeignKeyOptions, type ForeignKeyTarget, type ForeignKeyTargetInput, type Fragment, type FragmentMeta, type FromClause, type FromScope, type FromSource, type GeneratedColumnDescriptor, type GeneratedColumnMode, type GeneratedDescriptor, type GroupingDependenciesOf, type GroupingKeysOf, type GroupingMeta, type GroupingValidation, type HasAggregate, type HasSubquery, type HasWindow, type HookErrorOutcome, type HookMetadata, type HookMetadataValue, type HookOperation, type HookOperationKind, type HookOutcome, type HookQueryOperation, type HookStreamEnd, type HookSuccessOutcome, type HookTransactionOperation, type IdentityDescriptor, type IdentityDialectExtension, type IdentityGeneration, type IndexDialectExtension, type IndexOptions, type IndexTerm, type InheritedMetadata, type InheritedMetadataOf, type InsertSelectSource, type InsertSource, type JsonPath, type JsonScalarKind, type KeyConstraint, type KeyConstraintOptions, type LateralIdentity, type LateralSource, type LiteralDefaultDescriptor, type MetadataOf, type MissingScope, type MutationClause, type MutationKind, type MutationQuery, type MutationQueryConfig, type MutationReturning, type MutationReturningClause, type MutationRow, type MutationScopeValidation, type MutationSqlTypes, type MysqlConstraintExtension, type MysqlIdentityExtension, type MysqlIndexExtension, type NamedCastTarget, type NativeColumnStorage, type NullabilityOf, type NullableSourceMeta, type NullableSourcesOf, type Omit, type OmittableSelectClause, type OperationEndHook, type OrderTerm, type OutputOf, type PaginationKind, type PaginationPart, type PortableCastTarget, type PortableCastType, type PortableColumnStorage, type PostgresConstraintExtension, type PostgresIndexExtension, type ProvidedSourceIdentity, type ProvidedSourceRow, type ProvidesOuterOf, type ProvidesOuterSourceMeta, type ProvidesSourceMeta, type QubuClient, type QubuExplainableClient, type QubuExplainableStreamingTransactionalClient, type QubuExplainableTransactionalClient, type QubuHooks, type QubuOptions, type QubuStreamingClient, type QubuStreamingExplainableClient, type QubuStreamingTransaction, type QubuStreamingTransactionalClient, type QubuTransaction, type QubuTransactionalClient, type Query, type QueryAdapter, type QueryAliasIdentity, type QueryCardinality, type QueryConfig, type QueryExecutor, type QueryKind, type QueryRow, type QuerySource, type QuerySqlTypeMap, type QueryTypeValidation, QueryValidationError, type QueryValidationErrorCode, type QueryValidationIssue, type QueryWithRow, type RecursiveCteSource, type ReferentialAction, type RenderContext, type RenderFunction, type RenderOptions, type RenderedQuery, type RenderedSchemaExpression, type RequiredOuterScope, type RequiredScope, type RequiresCapabilityMeta, type RequiresOf, type RequiresOuterMetadataOf, type RequiresOuterOf, type RequiresOuterSourceMeta, type RequiresSourceMeta, type ResolvedColumnBehavior, type ResultDecodeContext, type ResultDecoder, type ResultDecoders, ResultDecodingError, type ResultField, type ResultMeta, type ResultShape, type ReturningClause, type ReturningRow, type ReturningSqlTypes, type Row, type RowLockClause, type RowLockMode, type RowLockOptions, type RowLockWaitPolicy, type Schema, type SchemaDiagnostic, type SchemaDialect, type SchemaDialectExtension, type SchemaDialectHooks, type SchemaDialectName, type SchemaExpression, type SchemaExpressionBrand, type SchemaExpressionErrorCode, type SchemaExpressionInput, type SchemaExpressionMode, type SchemaLiteralRenderer, type SchemaLiteralValue, type SchemaMetadataDiagnostic, type SchemaNamingPolicy, type SchemaObjectIdentity, type SchemaObjectNameOptions, type SchemaOptions, type SchemaRenderContext, type SchemaRenderOptions, type SchemaTableEntry, type SchemaTableNames, type SchemaTableRecord, type SchemaTableRegistry, type ScopeValidation, type SelectCardinality, type SelectClause, type SelectPart, type SelectQuery, type Selection, type SelectionObject, type SelectionOutput, type SelectionSqlTypes, type SetOperator, type SetQuery, type Source, type SourceColumns, type SourceConfig, type SourceConstraint, type SourceConstraints, type SourceConstraintsRecord, type SourceIdentity, type SourceIndex, type SourceIndexesRecord, type SourceKind, type SourceLike, type SourceProvision, type SourceRow, type SourceSqlTypeMap, type SqlBigInt, type SqlBinary, type SqlBoolean, type SqlDate, type SqlDecimal, type SqlEqualityComparable, type SqlEqualityCompatible, type SqlFragment, type SqlInteger, type SqlJson, type SqlNumericLike, type SqlOrderCompatible, type SqlOrderable, type SqlSemanticType, type SqlTag, type SqlText, type SqlTextLike, type SqlTimestamp, type SqlTypeOf, type SqlTypeSatisfies, type SqlUnknown, type SqlUuid, type SqliteConstraintExtension, type SqliteIdentityExtension, type SqliteIndexExtension, type StreamableQuery, type StreamingQueryAdapter, type StreamingTransactionalQueryAdapter, type SubqueryMeta, type Table, type TableColumns, type TableDefinitions, type TableIdentity, type TableIndex, type TableInsertInput, type TableLike, type TableRow, type TableSqlTypes, type TableUpdateInput, type TransactionOptions, type TransactionalQueryAdapter, type TypedSqlTag, type UniqueConstraint, type UniqueConstraintOptions, type UniqueNullSemantics, type UnsafeSchemaSqlExpression, type UpdateAssignmentValue, type UpdateAssignments, type ValuesSource, type VisibleDependenciesOf, type WindowMeta, type WithClause, add, alias, all, allowAll, and, asValue, asc, avg, between, bigint, binary, boolean, booleanResultDecoder, call, caseWhen, cast, catalogCheck, catalogForeignKey, check, coalesce, column, concat, correlate, count, countDistinct, crossJoin, cte, date, dateResultDecoder, defaultValues, deleteFrom, denseRank, desc, distinct, divide, eq, except, execute, executeRows, exists, explain, externalDefault, externalGeneratedColumn, fetchFirst, fetchNext, foreignKey, from, fullJoin, generatedColumn, groupBy, gt, gte, having, identityColumn, inList, inQuery, index, innerJoin, insertInto, insertSelect, integer, intersect, isDistinctFrom, isNotDistinctFrom, isNotNull, isNull, isTrue, json, jsonBoolean, jsonExists, jsonNumber, jsonPath, jsonText, jsonTextResultDecoder, lateral, leftJoin, like, lower, lt, lte, mapResult, max, min, modulo, multiply, nativeColumn, nativeStorage, naturalJoin, ne, not, notExists, notIn, notLike, nullable, nullsFirst, nullsLast, numeric, offset, omit, or, order, orderBy, over, portableStorage, primaryKey, qubu, rank, recursiveCte, references, render, returning, rightJoin, rowLock, rowNumber, scalar, schema, schemaCall, select, sql, stream, subtract, sum, table, text, timestamp, timestampResultDecoder, union, unionAll, unique, uniqueConstraint, unsafeSchemaSql, update, upper, uuid, value, values, where, withCte };
+import { $ as PaginationKind, $a as countDistinct, $c as QubuExplainableTransactionalClient, $i as IndexOptions, $l as booleanResultDecoder, $n as ScopeValidation, $o as ColumnOutput, $r as SchemaTableNames, $s as IdentityDescriptor, $t as nullsLast, $u as SqlDecimal, Aa as divide, Ac as ExecutionResult, Ai as SqliteConstraintExtension, An as MutationClause, Ar as SchemaDialect, As as integer, At as SourceSqlTypeMap, Au as QueryCardinality, B as CastTarget, Ba as denseRank, Bc as HookMetadata, Bi as references, Bl as SchemaExpression, Bn as ReturningClause, Bo as ColumnDefaultOf, Br as UnsafeSchemaSqlExpression, Bs as CanonicalLiteral, Bt as TableDefinitions, Bu as SqlTypeOf, Ca as offset, Ci as KeyConstraintOptions, Cl as render, Cn as UpdateAssignmentValue, Co as between, Cr as FromSource, Cs as bigint, Ct as SourceColumns, Cu as NullabilityOf, Da as ClausePlacement, Dc as DriverValueEncoder, Di as SourceConstraint, Dl as QueryValidationIssue, Do as isNull, Dr as SelectionOutput, Dt as SourceKind, Du as ProvidesOuterOf, Ea as AnySelectClause, Ec as AdapterExecutionResult, Ei as ReferentialAction, El as QueryValidationErrorCode, Eo as isNotNull, Er as SelectionObject, Es as column, Et as SourceIdentity, Eu as OutputOf, Fa as jsonBoolean, Fc as ExplainReadOptions, Fi as catalogCheck, Fl as ExpressionNullability, Fn as MutationReturningClause, Fo as value, Fr as SchemaExpressionErrorCode, Fs as numeric, Fu as RequiresOuterMetadataOf, G as DialectJson, Ga as concat, Gc as HookQueryOperation, Gi as AliasedSource, Gn as select, Go as ColumnHasDefault, Gs as DefaultDescriptor, Gt as TableRow, H as DialectCapability, Ha as rank, Hc as HookOperation, Hi as uniqueConstraint, Hn as ReturningSqlTypes, Ho as ColumnDefinitionConfig, Hs as ColumnBehaviorErrorCode, Ht as TableInsertInput, Hu as VisibleDependenciesOf, Ia as jsonExists, Ic as ExplainRequest, Ii as catalogForeignKey, Il as ExpressionOutput, In as MutationRow, Io as mapResult, Ir as SchemaExpressionInput, Is as portableStorage, Iu as RequiresOuterOf, J as DialectRowLocking, Ja as call, Jc as HookTransactionOperation, Ji as QueryAliasIdentity, Jl as ResultDecoder, Jn as ClauseScope, Jo as ColumnInsertInput, Jr as Schema, Js as ExternalDefaultDescriptor, Jt as table, Ju as AnySqlType, K as DialectOptions, Ka as lower, Kc as HookStreamEnd, Ki as LateralIdentity, Kl as DecodableResultType, Kn as AvailableOuterScope, Ko as ColumnHasRuntimeDefault, Ks as ExpressionDefaultDescriptor, Kt as TableSqlTypes, La as jsonNumber, Lc as ExplainResult, Li as check, Ll as ExpressionRequires, Ln as MutationScopeValidation, Lo as cast, Lr as SchemaExpressionMode, Ls as text, Lt as AnyTable, Lu as RequiresOuterSourceMeta, Ma as multiply, Mc as ExplainOptions, Mi as UniqueConstraint, Ml as AnySchemaExpression, Mn as MutationQuery, Ms as nativeColumn, Mu as RenderFunction, Na as subtract, Nc as ExplainOptionsFor, Ni as UniqueConstraintOptions, Nl as Expression, Nn as MutationQueryConfig, No as asValue, Nr as RenderedSchemaExpression, Ns as nativeStorage, Nu as RequiresCapabilityMeta, Oa as SelectClause, Oc as ExecutionOptions, Oi as SourceConstraintsRecord, Ol as ColumnDependency, Oo as isTrue, Or as SelectionSqlTypes, Os as date, Ot as SourceProvision, Ou as ProvidesOuterSourceMeta, Pa as JsonPath, Pc as ExplainPlanRow, Pi as UniqueNullSemantics, Pl as ExpressionKind, Pn as MutationReturning, Ps as nullable, Pu as RequiresOf, Q as NamedCastTarget, Qa as count, Qc as QubuExplainableStreamingTransactionalClient, Qi as IndexDialectExtension, Ql as ResultShape, Qn as RequiredScope, Qo as ColumnOptions, Qr as SchemaTableEntry, Qs as GeneratedDescriptor, Qt as nullsFirst, Qu as SqlDate, Ra as jsonPath, Rc as ExplainableQueryAdapter, Ri as foreignKey, Rl as ExpressionSqlType, Rn as MutationSqlTypes, Rr as SchemaRenderContext, Rs as timestamp, Rt as Table, Ru as RequiresSourceMeta, Sa as fetchNext, Si as KeyConstraint, Sl as RenderedQuery, So as notLike, Sr as FromScope, St as Source, Su as MetadataOf, Ta as distinct, Ti as PostgresConstraintExtension, Tl as QueryValidationError, Tn as update, To as notIn, Tr as Selection, Ts as boolean, Tt as SourceConstraints, Tu as NullableSourcesOf, U as DialectCastTypes, Ua as rowNumber, Uc as HookOperationKind, Un as returning, Us as ColumnDefault, Uu as WindowMeta, V as Dialect, Va as over, Vc as HookMetadataValue, Vi as unique, Vl as SchemaExpressionBrand, Vn as ReturningRow, Vo as ColumnDefinition, Vs as ColumnBehaviorError, Vt as TableIdentity, Vu as SubqueryMeta, W as DialectExplain, Wa as coalesce, Wc as HookOutcome, Wi as AliasIdentity, Wn as correlate, Wo as ColumnGeneratedOf, Ws as ColumnDefaultInput, X as ExplainRenderOptions, Xc as QubuClient, Xi as alias, Xl as ResultDecodingError, Xn as MissingScope, Xr as SchemaNamingPolicy, Xs as GeneratedColumnDescriptor, Xt as asc, Xu as SqlBinary, Y as ExplainFormat, Ya as schemaCall, Yc as OperationEndHook, Yi as QuerySource, Yl as ResultDecoders, Yn as GroupingValidation, Yo as ColumnIsGenerated, Yr as SchemaDiagnostic, Ys as ExternalGeneratedColumnDescriptor, Yt as OrderTerm, Yu as SqlBigInt, Z as JsonScalarKind, Za as avg, Zc as QubuExplainableClient, Zi as lateral, Zl as ResultField, Zn as RequiredOuterScope, Zo as ColumnOnUpdateOf, Zr as SchemaOptions, Zs as GeneratedColumnMode, Zt as desc, Zu as SqlBoolean, _a as where, _c as SchemaObjectIdentity, _i as ForeignKeyConstraint, _l as explain, _o as isNotDistinctFrom, _r as leftJoin, _t as AnySource, _u as HasAggregate, aa as SqliteIndexExtension, ac as SchemaLiteralValue, ad as SqlOrderCompatible, ai as schema, al as QubuStreamingTransactionalClient, an as InsertSource, ao as TypedSqlTag, ar as cte, as as ColumnStorageKindOf, at as SchemaLiteralRenderer, au as AnyFragment, ba as rowLock, bi as ForeignKeyTarget, bo as lte, br as groupBy, bt as ProvidedSourceIdentity, bu as InheritedMetadata, cc as externalDefault, cd as SqlText, ci as CatalogCheckExpression, cl as QueryAdapter, cn as ValuesSource, co as exists, cr as SetOperator, cs as ColumnStorageTypeOf, cu as CardinalityMeta, da as not, dc as identityColumn, dd as SqlTypeSatisfies, di as CheckConstraintOptions, dl as StreamingQueryAdapter, dn as insertSelect, do as scalar, dr as intersect, ds as NativeColumnStorage, dt as QueryConfig, du as ExpressionMeta, ea as IndexTerm, ec as IdentityDialectExtension, ed as SqlEqualityComparable, ei as SchemaTableRecord, el as QubuHooks, en as order, eo as max, er as SelectCardinality, es as ColumnSqlType, et as PaginationPart, eu as dateResultDecoder, fa as or, fd as SqlUnknown, fi as ConstraintDialectExtension, fl as StreamingTransactionalQueryAdapter, fn as values, fr as union, ft as QueryKind, fu as Fragment, ga as omit, gi as FieldLikeOptions, gl as executeRows, go as isDistinctFrom, gr as innerJoin, gt as Row, gu as GroupingMeta, ha as SelectPart, hc as SchemaMetadataDiagnostic, hi as FieldLike, hl as execute, ho as gte, hr as fullJoin, ht as QueryWithRow, hu as GroupingKeysOf, ia as SourceIndexesRecord, ic as ResolvedColumnBehavior, id as SqlNumericLike, il as QubuStreamingTransaction, in as InsertSelectSource, io as SqlTag, ir as WithClause, is as ColumnStorageDialectOf, it as RowLockWaitPolicy, iu as AggregateMeta, ja as modulo, jc as ExplainMutationOptions, ji as TableLike, jl as AnyExpression, jn as MutationKind, jr as SchemaDialectHooks, js as json, ju as RenderContext, ka as add, kc as ExecutionRequest, ki as SourceLike, kl as ColumnReference, kn as AllowAllClause, kr as all, kt as SourceRow, ku as ProvidesSourceMeta, la as DeclaredColumnNullability, lc as externalGeneratedColumn, ld as SqlTextLike, li as CatalogCheckSql, ll as QueryExecutor, ln as defaultValues, lo as inQuery, lr as SetQuery, ls as ColumnUpdateInput, lt as AnyQuery, lu as CardinalityOf, ma as OmittableSelectClause, mc as SchemaDialectName, mi as ConstraintTiming, ml as TransactionalQueryAdapter, mo as gt, mr as crossJoin, ms as PortableColumnStorage, mt as QuerySqlTypeMap, mu as GroupingDependenciesOf, na as PostgresIndexExtension, nc as LiteralDefaultDescriptor, nd as SqlInteger, nl as QubuStreamingClient, nn as deleteFrom, no as sum, nr as CteSource, ns as ColumnStorageDeclarationOf, nt as PortableCastType, nu as timestampResultDecoder, oa as TableIndex, oc as SqliteIdentityExtension, od as SqlOrderable, ol as QubuTransaction, on as InsertValue, oo as sql, or as recursiveCte, os as ColumnStorageOf, ou as CapabilitiesOf, pa as Omit, pc as SchemaDialectExtension, pd as SqlUuid, pi as ConstraintOptions, pl as TransactionOptions, po as eq, pr as unionAll, pt as QueryRow, pu as FragmentMeta, q as DialectPagination, qa as upper, qc as HookSuccessOutcome, qi as LateralSource, ql as ResultDecodeContext, qn as AvailableScope, qo as ColumnIdentityOf, qr as unsafeSchemaSql, qs as ExpressionGeneratedColumnDescriptor, qt as TableUpdateInput, ra as SourceIndex, rc as MysqlIdentityExtension, rd as SqlJson, rl as QubuStreamingExplainableClient, rn as DefaultValuesSource, ro as SqlFragment, rr as RecursiveCteSource, rt as RowLockMode, ru as AggregateDependenciesOf, sa as index, sd as SqlSemanticType, si as AnyKeyColumn, sl as QubuTransactionalClient, sn as InsertValuesRow, so as caseWhen, sr as withCte, su as CapabilityMetadataOf, ta as MysqlIndexExtension, tc as IdentityGeneration, td as SqlEqualityCompatible, ti as SchemaTableRegistry, tl as QubuOptions, tn as orderBy, to as min, tr as SelectQuery, ts as ColumnStorage, tt as PortableCastTarget, tu as jsonTextResultDecoder, ua as and, uc as generatedColumn, ud as SqlTimestamp, ui as CheckConstraint, ul as StreamableQuery, un as insertInto, uo as notExists, ur as except, ut as Query, uu as DependenciesOf, va as RowLockClause, vc as SchemaObjectNameOptions, vi as ForeignKeyMatch, vl as qubu, vo as like, vr as naturalJoin, vu as HasSubquery, wa as having, wi as MysqlConstraintExtension, wl as QueryTypeValidation, wn as UpdateAssignments, wo as inList, wr as from, ws as binary, wt as SourceConfig, wu as NullableSourceMeta, xa as fetchFirst, xi as ForeignKeyTargetInput, xl as RenderOptions, xo as ne, xr as FromClause, xt as ProvidedSourceRow, xu as InheritedMetadataOf, ya as RowLockOptions, yi as ForeignKeyOptions, yl as stream, yo as lt, yr as rightJoin, yu as HasWindow, za as jsonText, zc as HookErrorOutcome, zi as primaryKey, zl as ExpressionWithOutput, zn as allowAll, zo as ColumnCodec, zr as SchemaRenderOptions, zs as uuid, zt as TableColumns, zu as ResultMeta } from "./types-DUe6eeI0.mjs";
+export { type AdapterExecutionResult, type AggregateDependenciesOf, type AggregateMeta, type AliasIdentity, type AliasedSource, type AllowAllClause, type AnyExpression, type AnyFragment, type AnyKeyColumn, type AnyQuery, type AnySchemaExpression, type AnySelectClause, type AnySource, type AnySqlType, type AnyTable, type AvailableOuterScope, type AvailableScope, type CanonicalLiteral, type CapabilitiesOf, type CapabilityMetadataOf, type CardinalityMeta, type CardinalityOf, type CastTarget, type CatalogCheckExpression, type CatalogCheckSql, type CheckConstraint, type CheckConstraintOptions, type ClausePlacement, type ClauseScope, type ColumnBehaviorError, type ColumnBehaviorErrorCode, type ColumnCodec, type ColumnDefault, type ColumnDefaultInput, type ColumnDefaultOf, type ColumnDefinition, type ColumnDefinitionConfig, type ColumnDependency, type ColumnGeneratedOf, type ColumnHasDefault, type ColumnHasRuntimeDefault, type ColumnIdentityOf, type ColumnInsertInput, type ColumnIsGenerated, type ColumnOnUpdateOf, type ColumnOptions, type ColumnOutput, type ColumnReference, type ColumnSqlType, type ColumnStorage, type ColumnStorageDeclarationOf, type ColumnStorageDialectOf, type ColumnStorageKindOf, type ColumnStorageOf, type ColumnStorageTypeOf, type ColumnUpdateInput, type ConstraintDialectExtension, type ConstraintOptions, type ConstraintTiming, type CteSource, type DeclaredColumnNullability, type DecodableResultType, type DefaultDescriptor, type DefaultValuesSource, type DependenciesOf, type Dialect, type DialectCapability, type DialectCastTypes, type DialectExplain, type DialectJson, type DialectOptions, type DialectPagination, type DialectRowLocking, type DriverValueEncoder, type ExecutionOptions, type ExecutionRequest, type ExecutionResult, type ExplainFormat, type ExplainMutationOptions, type ExplainOptions, type ExplainOptionsFor, type ExplainPlanRow, type ExplainReadOptions, type ExplainRenderOptions, type ExplainRequest, type ExplainResult, type ExplainableQueryAdapter, type Expression, type ExpressionDefaultDescriptor, type ExpressionGeneratedColumnDescriptor, type ExpressionKind, type ExpressionMeta, type ExpressionNullability, type ExpressionOutput, type ExpressionRequires, type ExpressionSqlType, type ExpressionWithOutput, type ExternalDefaultDescriptor, type ExternalGeneratedColumnDescriptor, type FieldLike, type FieldLikeOptions, type ForeignKeyConstraint, type ForeignKeyMatch, type ForeignKeyOptions, type ForeignKeyTarget, type ForeignKeyTargetInput, type Fragment, type FragmentMeta, type FromClause, type FromScope, type FromSource, type GeneratedColumnDescriptor, type GeneratedColumnMode, type GeneratedDescriptor, type GroupingDependenciesOf, type GroupingKeysOf, type GroupingMeta, type GroupingValidation, type HasAggregate, type HasSubquery, type HasWindow, type HookErrorOutcome, type HookMetadata, type HookMetadataValue, type HookOperation, type HookOperationKind, type HookOutcome, type HookQueryOperation, type HookStreamEnd, type HookSuccessOutcome, type HookTransactionOperation, type IdentityDescriptor, type IdentityDialectExtension, type IdentityGeneration, type IndexDialectExtension, type IndexOptions, type IndexTerm, type InheritedMetadata, type InheritedMetadataOf, type InsertSelectSource, type InsertSource, type InsertValue, type InsertValuesRow, type JsonPath, type JsonScalarKind, type KeyConstraint, type KeyConstraintOptions, type LateralIdentity, type LateralSource, type LiteralDefaultDescriptor, type MetadataOf, type MissingScope, type MutationClause, type MutationKind, type MutationQuery, type MutationQueryConfig, type MutationReturning, type MutationReturningClause, type MutationRow, type MutationScopeValidation, type MutationSqlTypes, type MysqlConstraintExtension, type MysqlIdentityExtension, type MysqlIndexExtension, type NamedCastTarget, type NativeColumnStorage, type NullabilityOf, type NullableSourceMeta, type NullableSourcesOf, type Omit, type OmittableSelectClause, type OperationEndHook, type OrderTerm, type OutputOf, type PaginationKind, type PaginationPart, type PortableCastTarget, type PortableCastType, type PortableColumnStorage, type PostgresConstraintExtension, type PostgresIndexExtension, type ProvidedSourceIdentity, type ProvidedSourceRow, type ProvidesOuterOf, type ProvidesOuterSourceMeta, type ProvidesSourceMeta, type QubuClient, type QubuExplainableClient, type QubuExplainableStreamingTransactionalClient, type QubuExplainableTransactionalClient, type QubuHooks, type QubuOptions, type QubuStreamingClient, type QubuStreamingExplainableClient, type QubuStreamingTransaction, type QubuStreamingTransactionalClient, type QubuTransaction, type QubuTransactionalClient, type Query, type QueryAdapter, type QueryAliasIdentity, type QueryCardinality, type QueryConfig, type QueryExecutor, type QueryKind, type QueryRow, type QuerySource, type QuerySqlTypeMap, type QueryTypeValidation, QueryValidationError, type QueryValidationErrorCode, type QueryValidationIssue, type QueryWithRow, type RecursiveCteSource, type ReferentialAction, type RenderContext, type RenderFunction, type RenderOptions, type RenderedQuery, type RenderedSchemaExpression, type RequiredOuterScope, type RequiredScope, type RequiresCapabilityMeta, type RequiresOf, type RequiresOuterMetadataOf, type RequiresOuterOf, type RequiresOuterSourceMeta, type RequiresSourceMeta, type ResolvedColumnBehavior, type ResultDecodeContext, type ResultDecoder, type ResultDecoders, ResultDecodingError, type ResultField, type ResultMeta, type ResultShape, type ReturningClause, type ReturningRow, type ReturningSqlTypes, type Row, type RowLockClause, type RowLockMode, type RowLockOptions, type RowLockWaitPolicy, type Schema, type SchemaDiagnostic, type SchemaDialect, type SchemaDialectExtension, type SchemaDialectHooks, type SchemaDialectName, type SchemaExpression, type SchemaExpressionBrand, type SchemaExpressionErrorCode, type SchemaExpressionInput, type SchemaExpressionMode, type SchemaLiteralRenderer, type SchemaLiteralValue, type SchemaMetadataDiagnostic, type SchemaNamingPolicy, type SchemaObjectIdentity, type SchemaObjectNameOptions, type SchemaOptions, type SchemaRenderContext, type SchemaRenderOptions, type SchemaTableEntry, type SchemaTableNames, type SchemaTableRecord, type SchemaTableRegistry, type ScopeValidation, type SelectCardinality, type SelectClause, type SelectPart, type SelectQuery, type Selection, type SelectionObject, type SelectionOutput, type SelectionSqlTypes, type SetOperator, type SetQuery, type Source, type SourceColumns, type SourceConfig, type SourceConstraint, type SourceConstraints, type SourceConstraintsRecord, type SourceIdentity, type SourceIndex, type SourceIndexesRecord, type SourceKind, type SourceLike, type SourceProvision, type SourceRow, type SourceSqlTypeMap, type SqlBigInt, type SqlBinary, type SqlBoolean, type SqlDate, type SqlDecimal, type SqlEqualityComparable, type SqlEqualityCompatible, type SqlFragment, type SqlInteger, type SqlJson, type SqlNumericLike, type SqlOrderCompatible, type SqlOrderable, type SqlSemanticType, type SqlTag, type SqlText, type SqlTextLike, type SqlTimestamp, type SqlTypeOf, type SqlTypeSatisfies, type SqlUnknown, type SqlUuid, type SqliteConstraintExtension, type SqliteIdentityExtension, type SqliteIndexExtension, type StreamableQuery, type StreamingQueryAdapter, type StreamingTransactionalQueryAdapter, type SubqueryMeta, type Table, type TableColumns, type TableDefinitions, type TableIdentity, type TableIndex, type TableInsertInput, type TableLike, type TableRow, type TableSqlTypes, type TableUpdateInput, type TransactionOptions, type TransactionalQueryAdapter, type TypedSqlTag, type UniqueConstraint, type UniqueConstraintOptions, type UniqueNullSemantics, type UnsafeSchemaSqlExpression, type UpdateAssignmentValue, type UpdateAssignments, type ValuesSource, type VisibleDependenciesOf, type WindowMeta, type WithClause, add, alias, all, allowAll, and, asValue, asc, avg, between, bigint, binary, boolean, booleanResultDecoder, call, caseWhen, cast, catalogCheck, catalogForeignKey, check, coalesce, column, concat, correlate, count, countDistinct, crossJoin, cte, date, dateResultDecoder, defaultValues, deleteFrom, denseRank, desc, distinct, divide, eq, except, execute, executeRows, exists, explain, externalDefault, externalGeneratedColumn, fetchFirst, fetchNext, foreignKey, from, fullJoin, generatedColumn, groupBy, gt, gte, having, identityColumn, inList, inQuery, index, innerJoin, insertInto, insertSelect, integer, intersect, isDistinctFrom, isNotDistinctFrom, isNotNull, isNull, isTrue, json, jsonBoolean, jsonExists, jsonNumber, jsonPath, jsonText, jsonTextResultDecoder, lateral, leftJoin, like, lower, lt, lte, mapResult, max, min, modulo, multiply, nativeColumn, nativeStorage, naturalJoin, ne, not, notExists, notIn, notLike, nullable, nullsFirst, nullsLast, numeric, offset, omit, or, order, orderBy, over, portableStorage, primaryKey, qubu, rank, recursiveCte, references, render, returning, rightJoin, rowLock, rowNumber, scalar, schema, schemaCall, select, sql, stream, subtract, sum, table, text, timestamp, timestampResultDecoder, union, unionAll, unique, uniqueConstraint, unsafeSchemaSql, update, upper, uuid, value, values, where, withCte };