qubu 0.0.0 → 0.3.4

package/dist/postgres-DEBBeh52.mjs

@@ -0,0 +1,235 @@
+import { A as isValidSchemaObjectName, _ as isUnsafeSchemaSql, m as validateConstraintDialect, w as validateIndexDialect, y as renderSchemaExpression } from "./registry-BufIskVN.mjs";
+import { t as createSchemaDialect } from "./dialect-b2-Z6uBF.mjs";
+import { a as toSnapshotJsonValue } from "./canonical-BbnqavJm.mjs";
+import { n as createSchemaSnapshot, s as tryCreateSchemaSnapshot } from "./serialize-PF1cfH2P.mjs";
+import { postgresDialect } from "./postgres.mjs";
+//#region src/snapshot/postgres.ts
+/** PostgreSQL's v1 snapshot extension identity. */
+const postgresSnapshotDialect = Object.freeze({
+	name: "postgresql",
+	version: 1
+});
+var PostgresSnapshotDialectError = class extends TypeError {
+	code = "dialect-mismatch";
+};
+const postgresStorageTypes = Object.freeze({
+	integer: "INTEGER",
+	numeric: "NUMERIC",
+	text: "TEXT",
+	boolean: "BOOLEAN",
+	date: "DATE",
+	timestamp: "TIMESTAMP",
+	uuid: "UUID",
+	json: "JSONB",
+	bigint: "BIGINT",
+	binary: "BYTEA"
+});
+/** PostgreSQL's query dialect plus its schema metadata behavior. */
+const postgresSchemaDialect = createSchemaDialect(postgresDialect(), {
+	version: 1,
+	validate: validatePostgresSchema,
+	encodeStorage(storage, context) {
+		return encodePostgresStorage(storage, context.dialect);
+	},
+	encodeExpression(expression, context) {
+		return encodePostgresExpression(expression, context.mode, context.dialect);
+	},
+	encodeDialectExtension(extension, context) {
+		return encodePostgresExtension(extension, context.dialect);
+	}
+});
+/** Snapshot adapter retaining the historical adapter-shaped entry point. */
+const postgresSnapshotAdapter = Object.freeze({ dialect: postgresSchemaDialect });
+/** Create a canonical PostgreSQL schema snapshot. */
+function createPostgresSchemaSnapshot(schema, options = {}) {
+	return createSchemaSnapshot(schema, {
+		...options,
+		adapter: postgresSnapshotAdapter
+	});
+}
+/** Return PostgreSQL capability diagnostics without throwing. */
+function tryCreatePostgresSchemaSnapshot(schema, options = {}) {
+	return tryCreateSchemaSnapshot(schema, {
+		...options,
+		adapter: postgresSnapshotAdapter
+	});
+}
+function encodePostgresStorage(storage, dialect) {
+	if (storage.kind === "native") {
+		if (storage.dialect !== dialect.name) throw new TypeError(`PostgreSQL storage cannot encode a native declaration owned by "${storage.dialect}"`);
+		if (storage.type.trim().length === 0) throw new TypeError("PostgreSQL native storage declarations cannot be empty");
+		return {
+			kind: "native",
+			dialect: dialect.name,
+			type: storage.type
+		};
+	}
+	const type = postgresStorageTypes[storage.type];
+	if (type === void 0) throw new TypeError(`Unsupported portable storage type for PostgreSQL: ${String(storage.type)}`);
+	return {
+		kind: "native",
+		dialect: dialect.name,
+		type
+	};
+}
+function encodePostgresExpression(expression, mode, dialect) {
+	if (isUnsafeSchemaSql(expression) && expression.schemaSqlDialect !== dialect.name) throw new PostgresSnapshotDialectError(`Schema SQL is tagged for "${expression.schemaSqlDialect}" but the PostgreSQL schema dialect is "${dialect.name}"`);
+	const rendered = renderSchemaExpression(expression, {
+		mode,
+		dialect
+	});
+	if (rendered.parameters.length !== 0) throw new TypeError("PostgreSQL schema expressions must be parameter-free");
+	return {
+		kind: "expression",
+		expressionKind: expression.expressionKind,
+		sql: rendered.text,
+		...isUnsafeSchemaSql(expression) ? { dialect: dialect.name } : {}
+	};
+}
+function encodePostgresExtension(extension, dialect) {
+	if (extension.dialect !== dialect.name) throw new TypeError(`PostgreSQL schema extensions require dialect "${dialect.name}"`);
+	const data = Object.fromEntries(Object.entries(extension).filter(([key]) => key !== "dialect").sort(([left], [right]) => left.localeCompare(right)));
+	return {
+		dialect: dialect.name,
+		version: dialect.schema.version,
+		data: sortSnapshotJson(toSnapshotJsonValue(data))
+	};
+}
+function sortSnapshotJson(value) {
+	if (Array.isArray(value)) return value.map(sortSnapshotJson);
+	if (typeof value !== "object" || value === null) return value;
+	return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortSnapshotJson(child)]));
+}
+function validatePostgresSchema(schema, context) {
+	const diagnostics = [];
+	const tableEntries = Object.entries(schema.registry).sort(([left], [right]) => compareIds(left, right));
+	const relationNames = /* @__PURE__ */ new Map();
+	if (schema.namespace !== void 0) validatePostgresName(schema.namespace, ["namespace"], "PostgreSQL namespace", diagnostics);
+	for (const [id, entry] of tableEntries) {
+		const tablePath = ["tables", id];
+		validatePostgresName(entry.physicalName, [...tablePath, "physicalName"], "PostgreSQL table", diagnostics);
+		addRelationName(relationNames, entry.physicalName, [...tablePath, "physicalName"], "table", diagnostics);
+	}
+	for (const [id, entry] of tableEntries) validatePostgresTable(id, entry, context, relationNames, diagnostics);
+	return Object.freeze(diagnostics);
+}
+function validatePostgresTable(tableId, entry, context, relationNames, diagnostics) {
+	const table = entry.table;
+	const tablePath = ["tables", tableId];
+	const definitions = table.definitions;
+	for (const [columnId, definition] of Object.entries(definitions).sort(([left], [right]) => compareIds(left, right))) {
+		validatePostgresName(table.sqlNames[columnId] ?? columnId, [
+			...tablePath,
+			"columns",
+			columnId,
+			"physicalName"
+		], "PostgreSQL column", diagnostics);
+		if (definition.onUpdate !== void 0) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "MySQL ON UPDATE expressions are not supported by PostgreSQL",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"onUpdate"
+			]
+		});
+		const generated = definition.generatedColumn;
+		if (generated !== void 0 && generated.kind === "expression" && generated.mode === "virtual") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL v1 snapshots support stored generated columns only; virtual generated columns are not supported",
+			path: [
+				...tablePath,
+				"columns",
+				columnId,
+				"generatedColumn",
+				"mode"
+			]
+		});
+	}
+	const metadata = table;
+	const constraintNames = /* @__PURE__ */ new Map();
+	const constraints = Object.entries(metadata.constraints);
+	for (const [constraintId, constraint] of constraints.sort(([left], [right]) => compareIds(left, right))) {
+		const constraintPath = [
+			...tablePath,
+			"constraints",
+			constraintId
+		];
+		const physicalName = constraint.physicalName ?? constraintId;
+		validatePostgresName(physicalName, [...constraintPath, "physicalName"], "PostgreSQL constraint", diagnostics);
+		addScopedName(constraintNames, physicalName, [...constraintPath, "physicalName"], "constraint", diagnostics);
+		appendMetadataDiagnostics(diagnostics, validateConstraintDialect(constraint, context.dialect.name, constraintPath));
+		if (constraint.kind === "check" && constraint.deferrable === true) diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL CHECK constraints cannot be DEFERRABLE",
+			path: [...constraintPath, "deferrable"]
+		});
+		if (constraint.kind === "foreign-key" && constraint.match === "partial") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL does not implement MATCH PARTIAL foreign keys",
+			path: [...constraintPath, "match"]
+		});
+		if (constraint.kind === "unique-constraint" && constraint.nulls === "not-distinct") diagnostics.push({
+			code: "unsupported-dialect-option",
+			message: "PostgreSQL NULLS NOT DISTINCT requires a server-version policy; the v1 adapter does not assume PostgreSQL 15 or newer",
+			path: [...constraintPath, "nulls"]
+		});
+	}
+	const indexes = Object.entries(metadata.indexes);
+	for (const [indexId, index] of indexes.sort(([left], [right]) => compareIds(left, right))) {
+		const indexPath = [
+			...tablePath,
+			"indexes",
+			indexId
+		];
+		const physicalName = index.physicalName ?? indexId;
+		validatePostgresName(physicalName, [...indexPath, "physicalName"], "PostgreSQL index", diagnostics);
+		addRelationName(relationNames, physicalName, [...indexPath, "physicalName"], "index", diagnostics);
+		appendMetadataDiagnostics(diagnostics, validateIndexDialect(index, context.dialect.name, indexPath));
+	}
+}
+function validatePostgresName(name, path, kind, diagnostics) {
+	if (!isValidSchemaObjectName(name) || name.length === 0) diagnostics.push({
+		code: "invalid-schema",
+		message: `${kind} name "${name}" is not a valid unqualified identifier`,
+		path
+	});
+	if (new TextEncoder().encode(name).length > 63) diagnostics.push({
+		code: "unsupported-dialect-option",
+		message: `${kind} name exceeds PostgreSQL's 63-byte identifier limit`,
+		path
+	});
+}
+function addRelationName(names, name, path, kind, diagnostics) {
+	addScopedName(names, name, path, kind, diagnostics);
+}
+function addScopedName(names, name, path, kind, diagnostics) {
+	const previousPath = names.get(name);
+	if (previousPath !== void 0) {
+		diagnostics.push({
+			code: "invalid-schema",
+			message: `PostgreSQL ${kind} name "${name}" collides with another relation or metadata object`,
+			path,
+			relatedPaths: [previousPath]
+		});
+		return;
+	}
+	names.set(name, path);
+}
+function appendMetadataDiagnostics(diagnostics, issues) {
+	for (const issue of issues) {
+		if (issue.code === "dialect-mismatch") continue;
+		diagnostics.push({
+			code: issue.code === "unsupported-dialect-option" ? "unsupported-dialect-option" : "invalid-schema",
+			message: issue.message,
+			path: issue.path,
+			...issue.relatedPaths === void 0 ? {} : { relatedPaths: issue.relatedPaths }
+		});
+	}
+}
+function compareIds(left, right) {
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+//#endregion
+export { tryCreatePostgresSchemaSnapshot as a, postgresSnapshotDialect as i, postgresSchemaDialect as n, postgresSnapshotAdapter as r, createPostgresSchemaSnapshot as t };

package/dist/postgres.d.mts

@@ -0,0 +1,123 @@
+import { Cl as ExpressionMeta, Cn as ExcludedSource, Dn as excluded, En as doUpdate, Gl as RequiresCapabilityMeta, Ia as Operand, La as OperandNullability, On as onConflict, Pl as MetadataOf, Ra as OperandSqlType, Sn as DoUpdateAction, Tn as doNothing, V as Dialect, Zl as ResultMeta, bn as ConflictTarget, ll as ExpressionWithOutput, lu as SqlBoolean, ou as AnySqlType, ul as SchemaExpression, wn as OnConflictClause, wu as SqlUnknown, xn as DoNothingAction, xu as SqlTextLike, ya as ComparisonValidation, yn as ConflictAction, za as SqlCapabilityValidation } from "./types-4Q076HKo.mjs";
+//#region src/dialects/postgres.d.ts
+/**
+ * PostgreSQL's only core rendering difference is positional parameters.
+ * PostgreSQL-specific expressions and clauses should remain separate modules.
+ */
+declare function postgresDialect(): Dialect<"json" | "ilike" | "on-conflict" | "row-locking">;
+/** PostgreSQL's case-insensitive pattern-match operator. */
+declare function ilike<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, 'ILIKE'>, pattern: R): SchemaExpression<ResultMeta<boolean, ((MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+  readonly kind: "result";
+} ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
+  readonly kind: "result";
+} ? T_2 : never : never : never) ? T_1 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
+  readonly kind: "result";
+} ? T_3 : never : never : never) extends (infer T_4) ? T_4 extends (MetadataOf<TLeft> extends (infer T_5) ? T_5 extends MetadataOf<TLeft> ? T_5 extends {
+  readonly kind: "result";
+} ? T_5 : never : never : never) ? T_4 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>> extends (infer T_6) ? T_6 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_7) ? T_7 extends MetadataOf<TLeft> ? T_7 extends {
+  readonly kind: "result";
+} ? T_7 : never : never : never) extends (infer T_8) ? T_8 extends (MetadataOf<TLeft> extends (infer T_9) ? T_9 extends MetadataOf<TLeft> ? T_9 extends {
+  readonly kind: "result";
+} ? T_9 : never : never : never) ? T_8 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_10) ? T_10 extends MetadataOf<TLeft> ? T_10 extends {
+  readonly kind: "result";
+} ? T_10 : never : never : never) extends (infer T_11) ? T_11 extends (MetadataOf<TLeft> extends (infer T_12) ? T_12 extends MetadataOf<TLeft> ? T_12 extends {
+  readonly kind: "result";
+} ? T_12 : never : never : never) ? T_11 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>> ? T_6 extends {
+  readonly kind: "result";
+} ? T_6 : never : never : never) extends (infer T_13) ? T_13 extends (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_14) ? T_14 extends MetadataOf<TLeft> ? T_14 extends {
+  readonly kind: "result";
+} ? T_14 : never : never : never) extends (infer T_15) ? T_15 extends (MetadataOf<TLeft> extends (infer T_16) ? T_16 extends MetadataOf<TLeft> ? T_16 extends {
+  readonly kind: "result";
+} ? T_16 : never : never : never) ? T_15 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_17) ? T_17 extends MetadataOf<TLeft> ? T_17 extends {
+  readonly kind: "result";
+} ? T_17 : never : never : never) extends (infer T_18) ? T_18 extends (MetadataOf<TLeft> extends (infer T_19) ? T_19 extends MetadataOf<TLeft> ? T_19 extends {
+  readonly kind: "result";
+} ? T_19 : never : never : never) ? T_18 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>> extends (infer T_20) ? T_20 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_21) ? T_21 extends MetadataOf<TLeft> ? T_21 extends {
+  readonly kind: "result";
+} ? T_21 : never : never : never) extends (infer T_22) ? T_22 extends (MetadataOf<TLeft> extends (infer T_23) ? T_23 extends MetadataOf<TLeft> ? T_23 extends {
+  readonly kind: "result";
+} ? T_23 : never : never : never) ? T_22 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_24) ? T_24 extends MetadataOf<TLeft> ? T_24 extends {
+  readonly kind: "result";
+} ? T_24 : never : never : never) extends (infer T_25) ? T_25 extends (MetadataOf<TLeft> extends (infer T_26) ? T_26 extends MetadataOf<TLeft> ? T_26 extends {
+  readonly kind: "result";
+} ? T_26 : never : never : never) ? T_25 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>> ? T_20 extends {
+  readonly kind: "result";
+} ? T_20 : never : never : never) ? T_13 extends {
+  readonly nullableFrom: infer TSource;
+} ? TSource : never : never : never) | OperandNullability<R>, SqlBoolean> | ExpressionMeta<(MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_27) ? T_27 extends MetadataOf<TLeft> ? T_27 extends {
+  readonly kind: "result";
+} ? T_27 : never : never : never) extends (infer T_28) ? T_28 extends (MetadataOf<TLeft> extends (infer T_29) ? T_29 extends MetadataOf<TLeft> ? T_29 extends {
+  readonly kind: "result";
+} ? T_29 : never : never : never) ? T_28 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_30) ? T_30 extends MetadataOf<TLeft> ? T_30 extends {
+  readonly kind: "result";
+} ? T_30 : never : never : never) extends (infer T_31) ? T_31 extends (MetadataOf<TLeft> extends (infer T_32) ? T_32 extends MetadataOf<TLeft> ? T_32 extends {
+  readonly kind: "result";
+} ? T_32 : never : never : never) ? T_31 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>> extends (infer T_33) ? T_33 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_34) ? T_34 extends MetadataOf<TLeft> ? T_34 extends {
+  readonly kind: "result";
+} ? T_34 : never : never : never) extends (infer T_35) ? T_35 extends (MetadataOf<TLeft> extends (infer T_36) ? T_36 extends MetadataOf<TLeft> ? T_36 extends {
+  readonly kind: "result";
+} ? T_36 : never : never : never) ? T_35 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_37) ? T_37 extends MetadataOf<TLeft> ? T_37 extends {
+  readonly kind: "result";
+} ? T_37 : never : never : never) extends (infer T_38) ? T_38 extends (MetadataOf<TLeft> extends (infer T_39) ? T_39 extends MetadataOf<TLeft> ? T_39 extends {
+  readonly kind: "result";
+} ? T_39 : never : never : never) ? T_38 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>> ? T_33 extends {
+  readonly kind: "expression";
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never : never : never) | (MetadataOf<R> extends (infer T_40) ? T_40 extends MetadataOf<R> ? T_40 extends {
+  readonly kind: "expression";
+  readonly dependencies: infer TDependencies;
+} ? TDependencies : never : never : never)> | (MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_41) ? T_41 extends MetadataOf<TLeft> ? T_41 extends {
+  readonly kind: "result";
+} ? T_41 : never : never : never) extends (infer T_42) ? T_42 extends (MetadataOf<TLeft> extends (infer T_43) ? T_43 extends MetadataOf<TLeft> ? T_43 extends {
+  readonly kind: "result";
+} ? T_43 : never : never : never) ? T_42 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_44) ? T_44 extends MetadataOf<TLeft> ? T_44 extends {
+  readonly kind: "result";
+} ? T_44 : never : never : never) extends (infer T_45) ? T_45 extends (MetadataOf<TLeft> extends (infer T_46) ? T_46 extends MetadataOf<TLeft> ? T_46 extends {
+  readonly kind: "result";
+} ? T_46 : never : never : never) ? T_45 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>> extends (infer T_47) ? T_47 extends MetadataOf<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T_48) ? T_48 extends MetadataOf<TLeft> ? T_48 extends {
+  readonly kind: "result";
+} ? T_48 : never : never : never) extends (infer T_49) ? T_49 extends (MetadataOf<TLeft> extends (infer T_50) ? T_50 extends MetadataOf<TLeft> ? T_50 extends {
+  readonly kind: "result";
+} ? T_50 : never : never : never) ? T_49 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<R, (MetadataOf<TLeft> extends (infer T_51) ? T_51 extends MetadataOf<TLeft> ? T_51 extends {
+  readonly kind: "result";
+} ? T_51 : never : never : never) extends (infer T_52) ? T_52 extends (MetadataOf<TLeft> extends (infer T_53) ? T_53 extends MetadataOf<TLeft> ? T_53 extends {
+  readonly kind: "result";
+} ? T_53 : never : never : never) ? T_52 extends {
+  readonly sqlType: infer TSqlType extends AnySqlType;
+} ? TSqlType : SqlUnknown : never : never>, SqlTextLike>> ? T_47 extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T_47 : never : never) | (MetadataOf<R> extends (infer T_54) ? T_54 extends MetadataOf<R> ? T_54 extends {
+  readonly kind: "result" | "cardinality";
+} ? never : T_54 : never : never) | RequiresCapabilityMeta<"ilike">, "operator">;
+//#endregion
+export { type ConflictAction, type ConflictTarget, type DoNothingAction, type DoUpdateAction, type ExcludedSource, type OnConflictClause, doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect };

package/dist/postgres.mjs

@@ -0,0 +1,52 @@
+import { n as postgresJson, o as createDialect } from "./json-CUZlv4HT.mjs";
+import { f as withDialectCapability } from "./column-CXMxx8Hq.mjs";
+import { t as comparison } from "./relational-DCZrrNia.mjs";
+import { n as postgresExplain } from "./explain-CkIK13L_.mjs";
+import { i as onConflict, n as doUpdate, r as excluded, t as doNothing } from "./on-conflict-BxnxubMb.mjs";
+//#region src/dialects/postgres.ts
+const postgresRowLockModeSql = {
+	update: "UPDATE",
+	"no-key-update": "NO KEY UPDATE",
+	share: "SHARE",
+	"key-share": "KEY SHARE"
+};
+const postgresRowLocking = { render(context, mode, wait) {
+	context.append(`FOR ${postgresRowLockModeSql[mode]}`);
+	if (wait === "nowait") context.append(" NOWAIT");
+	if (wait === "skip-locked") context.append(" SKIP LOCKED");
+} };
+const postgresPagination = { render(context, parts) {
+	[...parts].sort((left, right) => {
+		return (left.kind === "fetch" ? 0 : 1) - (right.kind === "fetch" ? 0 : 1);
+	}).forEach((part, index) => {
+		if (index > 0) context.append(" ");
+		context.append(part.kind === "fetch" ? "LIMIT " : "OFFSET ");
+		context.parameter(part.rows);
+	});
+} };
+/**
+* PostgreSQL's only core rendering difference is positional parameters.
+* PostgreSQL-specific expressions and clauses should remain separate modules.
+*/
+function postgresDialect() {
+	return createDialect({
+		name: "postgresql",
+		placeholder: (position) => `$${position}`,
+		pagination: postgresPagination,
+		rowLocking: postgresRowLocking,
+		castTypes: { binary: "BYTEA" },
+		capabilities: [
+			"ilike",
+			"on-conflict",
+			"row-locking"
+		],
+		json: postgresJson,
+		explain: postgresExplain
+	});
+}
+/** PostgreSQL's case-insensitive pattern-match operator. */
+function ilike(left, pattern) {
+	return withDialectCapability(comparison("ILIKE", left, pattern), "ilike");
+}
+//#endregion
+export { doNothing, doUpdate, excluded, ilike, onConflict, postgresDialect };