@prisma/orm-target-sqlite 8.0.0-rc.2-dev.2 → 8.0.0-rc.20-dev.1

package/README.md

@@ -1,6 +1,6 @@
 # @prisma/orm-target-sqlite
 
-The concrete SQLite target of Prisma Next: the target descriptor (DDL planning, codecs, migration rendering), the SQLite adapter, and the driver.
+The concrete SQLite target of Prisma 8: the target descriptor (DDL planning, codecs, migration rendering), the SQLite adapter, and the driver.
 
 Applications receive it as an exact-pinned dependency of `@prisma/orm-sqlite`; app developers install that facade. Extension authors targeting SQLite and decomposed installs (for example, replacing the adapter while keeping the target and driver) import this package directly.
 
@@ -17,7 +17,3 @@ A bare namespace import (e.g. `@prisma/orm-target-sqlite/adapter`) aggregates th
 ## Responsibilities
 
 Everything SQLite-specific: native type normalization, DDL generation, control tables, and the database connection. Shared SQL semantics live in `@prisma/orm-family-sql`.
-
-## Dependencies
-
-`@prisma/orm-framework`, `@prisma/orm-family-sql`, and `@prisma/orm-toolchain` (exact lockstep pins), plus small third-party runtime libraries.

package/dist/{adapter-CUTKlFpX-CW0J0Qs4.mjs → adapter-7m8HU4rt-DN15_Cn8.mjs}

@@ -1,55 +1,26 @@
-import { i as SQLITE_DATETIME_CODEC_ID } from "./codec-ids-KMliSCRp-BhTbmbGr.mjs";
-import { n as buildSqliteCodecDescriptorRegistry } from "./codec-descriptor-B9ru99aI-DTkdKFU5.mjs";
-import { a as sqliteCodecDescriptorRegistry, o as sqliteCodecRegistry, t as jsonDocumentRetag } from "./codecs-BDdR6FbY.mjs";
-import { a as jsonText, i as integer, n as buildSignMarkerBootstrapQueries, o as sqliteTable, r as datetime, s as text, t as buildControlTableBootstrapQueries } from "./contract-free-D5cZrgNl.mjs";
-import { n as quoteIdentifier, t as escapeLiteral } from "./sql-utils-C2O4zVkP-Dz3Hb85I.mjs";
-import { t as parseSqliteDefault } from "./default-normalizer-DuoHj9-O-DsK7lJZn.mjs";
-import { t as normalizeSqliteNativeType } from "./native-type-normalizer-GpQMEyN5.mjs";
-import { RawExpr, isDdlNode } from "@prisma/orm-family-sql/relational-core/ast";
+import { i as SQLITE_DATETIME_CODEC_ID } from "./codec-ids-wgEvkCkg-WltuexMR.mjs";
+import { o as sqliteDataTypes } from "./data-types-coQrCWfS-yMCe4F52.mjs";
+import { r as jsonDocumentRetag } from "./codecs-yZoH21Yj-lQXtGlEq.mjs";
+import { n as SQLITE_NOW_EXPRESSION } from "./datetime-text-Bniwehv--BSQhnrdE.mjs";
+import { a as sqliteCodecRegistry, r as createSqliteCodecRegistryWithBuiltins } from "./codecs-g-YI3BtK.mjs";
+import { a as jsonText, i as integer, n as buildSignMarkerBootstrapQueries, o as sqliteTable, r as datetime, s as text, t as buildControlTableBootstrapQueries } from "./contract-free-DetowcoS.mjs";
+import { n as escapeLiteral, r as quoteIdentifier } from "./sql-utils-XGT5Esi2-Zr2mqJf8.mjs";
+import { t as readSqliteDefault } from "./default-normalizer-DGMXypHg-CPf7oyZA.mjs";
+import { RawExpr, encodeLiteralDefault, isDdlNode, renderOpaqueSql } from "@prisma/orm-family-sql/relational-core/ast";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { codecForRef } from "@prisma/orm-framework/components/codec";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-import { APP_SPACE_ID, extractCodecLookup } from "@prisma/orm-framework/components/control";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
+import { APP_SPACE_ID } from "@prisma/orm-framework/components/control";
+import { checkSqlDefaultText, contractColumns, readColumnDefault } from "@prisma/orm-family-sql/family/control";
 import { RelationalSchemaNodeKind, SqlSchemaIR, SqlTableIR } from "@prisma/orm-family-sql/schema-ir/types";
 import { REFERENTIAL_ACTION_SQL } from "@prisma/orm-family-sql/contract/referential-action-sql";
-import { InternalError, assertNever } from "@prisma/orm-framework/utils/internal-error";
 import { parseMarkerRowSafely, withMarkerReadErrorHandling } from "@prisma/orm-framework/errors/execution";
+import { resolveIntrospectedColumnType } from "@prisma/orm-family-sql/family/control-adapter";
 import { parseContractMarkerRow } from "@prisma/orm-family-sql/family/verify";
 import { createAstCodecRegistry, deriveParamMetadata, encodeParamsWithMetadata } from "@prisma/orm-family-sql/runtime";
-//#region ../../../3-targets/6-adapters/sqlite/dist/adapter-CUTKlFpX.mjs
-function descriptorsFrom(contributors) {
-	return contributors.flatMap((contributor) => contributor.types?.codecTypes?.codecDescriptors ?? []);
-}
-function buildSqliteCodecRegistry(descriptors) {
-	const descriptorRegistry = buildSqliteCodecDescriptorRegistry(descriptors);
-	const registry = {
-		...extractCodecLookup([{
-			id: "sqlite-codecs",
-			types: { codecTypes: { codecDescriptors: Array.from(descriptorRegistry.values()) } }
-		}]),
-		descriptorFor: (codecId) => descriptorRegistry.descriptorFor(codecId),
-		values: () => descriptorRegistry.values()
-	};
-	return Object.freeze(registry);
-}
-function assembleSqliteCodecRegistry(target, extensions) {
-	return buildSqliteCodecRegistry([
-		...descriptorsFrom([target]),
-		...sqliteCodecDescriptorRegistry.values(),
-		...descriptorsFrom(extensions)
-	]);
-}
-function createSqliteCodecRegistryWithBuiltins(codecDescriptors = []) {
-	return buildSqliteCodecRegistry([...sqliteCodecDescriptorRegistry.values(), ...codecDescriptors]);
-}
-/**
-* Build a coherent SQLite codec registry populated with built-in descriptors only.
-*
-* The returned registry supports both ordinary codec materialization and SQLite target behavior. Stack-composed paths build the same combined registry from target, full adapter, and ordered extension contributions.
-*/
-function createSqliteBuiltinCodecLookup() {
-	return createSqliteCodecRegistryWithBuiltins();
-}
+//#region ../../../3-targets/sqlite/2-adapter/dist/adapter-7m8HU4rt.mjs
 function ledgerOriginFromStored(originCoreHash) {
 	if (originCoreHash === null || originCoreHash === "" || originCoreHash === "empty") return null;
 	return originCoreHash;
@@ -120,7 +91,7 @@ const sqliteCatalog = sqliteTable("sqlite_master", {
 	name: text()
 });
 const NOW = new RawExpr({
-	parts: ["datetime('now')"],
+	parts: [SQLITE_NOW_EXPRESSION],
 	returns: {
 		codecId: SQLITE_DATETIME_CODEC_ID,
 		nullable: false
@@ -159,11 +130,12 @@ var SqliteControlAdapter = class {
 	familyId = "sql";
 	targetId = "sqlite";
 	codecRegistry;
-	constructor(codecRegistry) {
+	declaredDataTypes;
+	/** `declaredDataTypes` are the stack's data types in assembly order, which introspection resolves each column's reported type over. */
+	constructor(codecRegistry, declaredDataTypes) {
 		this.codecRegistry = codecRegistry;
+		this.declaredDataTypes = declaredDataTypes;
 	}
-	normalizeDefault = parseSqliteDefault;
-	normalizeNativeType = normalizeSqliteNativeType;
 	bootstrapControlTableQueries() {
 		return buildControlTableBootstrapQueries();
 	}
@@ -182,6 +154,13 @@ var SqliteControlAdapter = class {
 		if (isDdlNode(ast)) throw structuredError("RUNTIME.DDL_UNSUPPORTED", "lower() cannot lower DDL: DDL default literals require inline codec encoding, which is async. Use lowerToExecuteRequest().", { meta: { surface: "control-adapter" } });
 		return renderLoweredSql(ast, blindCast(context.contract), this.codecRegistry);
 	}
+	async renderColumnDefault(column, table) {
+		if (column.default === void 0) return "";
+		return sqliteRenderDdlColumnDefault(column.default, this.codecRegistry, column.codecRef, {
+			table,
+			column: column.name
+		});
+	}
 	/**
 	* Lower an AST all the way to a driver-ready statement. For DDL nodes,
 	* literal column defaults are formatted as inline SQL with SQLite-specific
@@ -314,9 +293,25 @@ var SqliteControlAdapter = class {
 			...mergedInvariants !== void 0 ? { invariants: mergedInvariants } : {}
 		}).where(marker.space.eq(space).and(marker.core_hash.eq(expectedFrom))).returning(marker.space).build())).length > 0;
 	}
+	async withTransaction(driver, fn) {
+		await driver.query("BEGIN IMMEDIATE");
+		let result;
+		try {
+			result = await fn();
+		} catch (error) {
+			try {
+				await driver.query("ROLLBACK");
+			} catch (rollbackError) {
+				if (error instanceof Error && error.cause === void 0) error.cause = rollbackError;
+			}
+			throw error;
+		}
+		await driver.query("COMMIT");
+		return result;
+	}
+	async lockMarker(_driver) {}
 	/**
-	* Appends a ledger entry for `space`. See the
-	* `SqlControlAdapter.writeLedgerEntry` contract.
+	* Appends a ledger entry for `space`. See the `SqlControlAdapter.writeLedgerEntry` contract.
 	*/
 	async writeLedgerEntry(driver, space, entry) {
 		await execute((query) => this.lower(query, { contract: void 0 }), driver, ledger.insert({
@@ -338,8 +333,31 @@ var SqliteControlAdapter = class {
 			record: parseContractMarkerRow(decodeSqliteMarkerRow(row))
 		};
 	}
-	async introspect(driver, _contract) {
-		const tablesResult = await driver.query(`SELECT name FROM sqlite_master
+	/**
+	* Reads a column's reported default: a function or SQL NULL as itself, and a literal with the column's codec, when the contract declares the column. A literal of a column the contract does not declare keeps only its raw text. When the contract's default is an expression that writes a literal, the codec reads that literal too, for the diff to compare the two values.
+	*/
+	async readReportedDefault(rawDefault, declaredType, column) {
+		const reported = readSqliteDefault(rawDefault, declaredType);
+		if (reported.kind === "function") return { resolvedDefault: reported };
+		if (reported.kind === "null") return { resolvedDefault: {
+			kind: "literal",
+			value: null
+		} };
+		const codec = column === void 0 ? void 0 : codecForRef(this.codecRegistry, column.codecRef);
+		if (codec === void 0) return {};
+		const expression = column?.defaultExpression;
+		const written = expression === void 0 ? void 0 : readSqliteDefault(expression, declaredType);
+		return readColumnDefault(codec, {
+			literal: reported.literal,
+			raw: rawDefault
+		}, expression !== void 0 && written?.kind === "literal" ? {
+			literal: written.literal,
+			expression
+		} : void 0);
+	}
+	async introspect(driver, contract) {
+		const contractColumnsOf = contractColumns(contract);
+		const tablesResult = await driver.query(`SELECT name, sql FROM sqlite_master
        WHERE type = 'table'
          AND name NOT LIKE 'sqlite_%'
          AND name NOT IN ('_prisma_marker', '_prisma_ledger')
@@ -347,21 +365,29 @@ var SqliteControlAdapter = class {
 		const tables = {};
 		for (const tableRow of tablesResult.rows) {
 			const tableName = tableRow.name;
-			const columnsResult = await driver.query(`PRAGMA table_info("${escapePragmaArg(tableName)}")`);
-			const fkResult = await driver.query(`PRAGMA foreign_key_list("${escapePragmaArg(tableName)}")`);
-			const indexListResult = await driver.query(`PRAGMA index_list("${escapePragmaArg(tableName)}")`);
+			const columnsResult = await driver.query(`PRAGMA table_info(${quoteIdentifier(tableName)})`);
+			const fkResult = await driver.query(`PRAGMA foreign_key_list(${quoteIdentifier(tableName)})`);
+			const indexListResult = await driver.query(`PRAGMA index_list(${quoteIdentifier(tableName)})`);
 			const columns = {};
 			const pkColumns = [];
+			const autoincrementColumn = autoincrementColumnOf(tableRow.sql, columnsResult.rows);
 			for (const col of columnsResult.rows) {
-				const resolvedNativeType = normalizeSqliteNativeType(col.type);
 				const rawDefault = col.dflt_value ?? void 0;
+				const readDefault = col.name === autoincrementColumn ? { resolvedDefault: AUTOINCREMENT_DEFAULT } : rawDefault === void 0 ? {} : await this.readReportedDefault(rawDefault, col.type, contractColumnsOf.columnOf(void 0, tableName, col.name));
+				const reportedType = {
+					text: col.type,
+					kind: void 0,
+					schema: void 0,
+					name: void 0
+				};
 				columns[col.name] = {
 					name: col.name,
-					nativeType: col.type.toLowerCase(),
+					typeText: col.type.toLowerCase(),
 					nullable: col.notnull === 0 && col.pk === 0,
 					...ifDefined("default", rawDefault),
-					resolvedNativeType,
-					...ifDefined("resolvedDefault", rawDefault !== void 0 ? parseSqliteDefault(rawDefault, resolvedNativeType) : void 0)
+					...readDefault,
+					reportedType,
+					...resolveIntrospectedColumnType(reportedType, this.declaredDataTypes)
 				};
 				if (col.pk > 0) pkColumns.push({
 					name: col.name,
@@ -398,7 +424,7 @@ var SqliteControlAdapter = class {
 			const uniques = [];
 			const indexes = [];
 			for (const idx of indexListResult.rows) {
-				const idxColumns = (await driver.query(`PRAGMA index_info("${escapePragmaArg(idx.name)}")`)).rows.sort((a, b) => a.seqno - b.seqno).map((r) => r.name);
+				const idxColumns = (await driver.query(`PRAGMA index_info(${quoteIdentifier(idx.name)})`)).rows.sort((a, b) => a.seqno - b.seqno).map((r) => r.name);
 				if (idx.origin === "u") uniques.push({
 					columns: Object.freeze([...idxColumns]),
 					name: idx.name,
@@ -431,9 +457,6 @@ var SqliteControlAdapter = class {
 		return new SqlSchemaIR({ tables });
 	}
 };
-function escapePragmaArg(name) {
-	return name.replace(/"/g, "\"\"");
-}
 const SQLITE_REFERENTIAL_ACTION_MAP = {
 	"NO ACTION": "noAction",
 	RESTRICT: "restrict",
@@ -475,16 +498,26 @@ function flatColumnDependsOn(tableName, columns) {
 		id: `column:${column}`
 	}]);
 }
-function sqliteInlineLiteral(wire) {
+function sqliteInlineLiteral(wire, where) {
 	if (wire === null) return "NULL";
 	if (typeof wire === "boolean") return wire ? "1" : "0";
 	if (typeof wire === "number") {
-		if (!Number.isFinite(wire)) throw structuredError("CONTRACT.DEFAULT_INVALID", `sqliteRenderDdlExecuteRequest: non-finite number wire value ${String(wire)} cannot be emitted as a DEFAULT literal`);
+		if (Number.isNaN(wire)) throw structuredError("CONTRACT.DEFAULT_INVALID", `Column "${where.table}"."${where.column}" has a NaN default, which SQLite stores as NULL`, { meta: {
+			table: where.table,
+			column: where.column,
+			value: "NaN",
+			reason: "nan-default"
+		} });
+		if (!Number.isFinite(wire)) return wire > 0 ? "9e999" : "-9e999";
 		return String(wire);
 	}
 	if (typeof wire === "bigint") return String(wire);
 	if (wire instanceof Date) {
-		if (Number.isNaN(wire.getTime())) throw structuredError("CONTRACT.DEFAULT_INVALID", "sqliteRenderDdlExecuteRequest: invalid Date value cannot be emitted as a DEFAULT literal");
+		if (Number.isNaN(wire.getTime())) throw structuredError("CONTRACT.DEFAULT_INVALID", `Column "${where.table}"."${where.column}" has an invalid Date default`, { meta: {
+			table: where.table,
+			column: where.column,
+			reason: "invalid-date-default"
+		} });
 		return `'${escapeLiteral(wire.toISOString())}'`;
 	}
 	if (typeof wire === "string") return `'${escapeLiteral(wire)}'`;
@@ -492,28 +525,47 @@ function sqliteInlineLiteral(wire) {
 	if (typeof wire === "object") return `'${escapeLiteral(JSON.stringify(wire))}'`;
 	throw structuredError("CONTRACT.PACK_CONTRIBUTION_INVALID", `sqliteRenderDdlExecuteRequest: unexpected wire type "${typeof wire}"`, { meta: { wireType: typeof wire } });
 }
-async function sqliteRenderDdlColumnDefault(def, codecLookup, codecRef) {
+const AUTOINCREMENT_DEFAULT = {
+	kind: "function",
+	expression: "autoincrement()"
+};
+/** `CREATE TABLE` text with its string literals, quoted identifiers and comments removed. */
+function createTableKeywords(createSql) {
+	return createSql.replace(/'(?:[^']|'')*'|"(?:[^"]|"")*"|`(?:[^`]|``)*`|\[[^\]]*\]|--[^\n]*|\/\*[\s\S]*?(?:\*\/|$)/g, " ");
+}
+/**
+* The column SQLite numbers with `AUTOINCREMENT`, which it keeps only in the table's `CREATE TABLE`
+* text. SQLite accepts the keyword only on a table's sole `INTEGER PRIMARY KEY` column.
+* See https://www.sqlite.org/autoinc.html.
+*/
+function autoincrementColumnOf(createSql, columns) {
+	if (!createSql || !/\bAUTOINCREMENT\b/i.test(createTableKeywords(createSql))) return;
+	const primaryKey = columns.filter((column) => column.pk > 0);
+	const [column] = primaryKey;
+	return primaryKey.length === 1 && column?.type.toUpperCase() === "INTEGER" ? column.name : void 0;
+}
+async function sqliteRenderDdlColumnDefault(def, codecLookup, codecRef, where) {
 	if (def.kind === "function") {
-		if (def.expression === "autoincrement()") return "";
-		if (def.expression === "now()") return "DEFAULT (datetime('now'))";
-		return `DEFAULT (${def.expression})`;
-	}
-	if (codecRef !== void 0) {
-		const codec = codecLookup.get(codecRef.codecId);
-		if (codec !== void 0) {
-			const value = def.value instanceof Date ? def.value : codec.decodeJson(def.value);
-			return `DEFAULT ${sqliteInlineLiteral(await codec.encode(value, {}))}`;
-		}
+		if (def.expression.text === "autoincrement()") return "";
+		if (def.expression.text === "now()") return `DEFAULT (${SQLITE_NOW_EXPRESSION})`;
+		if (checkSqlDefaultText(def.expression.text) !== void 0) throw structuredError("CONTRACT.DEFAULT_INVALID", `Unsafe default expression in contract: "${def.expression.text}". Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.`, { meta: { expression: def.expression.text } });
+		return `DEFAULT (${renderOpaqueSql(def.expression)})`;
 	}
-	return `DEFAULT ${sqliteInlineLiteral(def.value)}`;
+	const encoded = codecRef === void 0 ? void 0 : await encodeLiteralDefault(codecLookup, codecRef, def.value, where);
+	if (encoded?.kind === "sql-null") return "DEFAULT NULL";
+	if (encoded !== void 0) return `DEFAULT ${sqliteInlineLiteral(encoded.wire, where)}`;
+	return `DEFAULT ${sqliteInlineLiteral(def.value, where)}`;
 }
-async function sqliteRenderDdlColumn(column, codecLookup) {
+async function sqliteRenderDdlColumn(column, codecLookup, table) {
 	if (column.type.includes("AUTOINCREMENT")) return `${quoteIdentifier(column.name)} ${column.type}`;
 	const parts = [quoteIdentifier(column.name), column.type];
 	if (column.notNull) parts.push("NOT NULL");
 	if (column.primaryKey) parts.push("PRIMARY KEY");
 	if (column.default) {
-		const clause = await sqliteRenderDdlColumnDefault(column.default, codecLookup, column.codecRef);
+		const clause = await sqliteRenderDdlColumnDefault(column.default, codecLookup, column.codecRef, {
+			table,
+			column: column.name
+		});
 		if (clause.length > 0) parts.push(clause);
 	}
 	return parts.join(" ");
@@ -540,7 +592,7 @@ async function sqliteRenderDdlExecuteRequest(ast, codecLookup) {
 	const node = blindCast(ast);
 	const ifNotExists = node.ifNotExists ? "IF NOT EXISTS " : "";
 	const tableRef = quoteIdentifier(node.table);
-	const columnDefs = await Promise.all(node.columns.map((col) => sqliteRenderDdlColumn(col, codecLookup)));
+	const columnDefs = await Promise.all(node.columns.map((col) => sqliteRenderDdlColumn(col, codecLookup, node.table)));
 	const constraintDefs = node.constraints !== void 0 ? node.constraints.map(sqliteRenderDdlConstraint) : [];
 	return {
 		sql: `CREATE TABLE ${ifNotExists}${tableRef} (\n  ${[...columnDefs, ...constraintDefs].join(",\n  ")}\n)`,
@@ -560,16 +612,18 @@ const defaultCapabilities = Object.freeze({ sql: {
 	lateral: false,
 	jsonAgg: true,
 	returning: true,
-	enums: false
+	enums: false,
+	insertOnConflictSkip: true,
+	insertOnConflictWithoutTarget: true
 } });
 var SqliteAdapterImpl = class {
 	familyId = "sql";
 	targetId = "sqlite";
 	profile;
 	#codecs;
-	constructor(codecRegistry, profileId) {
+	constructor(codecRegistry, declaredDataTypes, profileId) {
 		this.#codecs = codecRegistry;
-		const controlAdapter = new SqliteControlAdapter(codecRegistry);
+		const controlAdapter = new SqliteControlAdapter(codecRegistry, declaredDataTypes);
 		this.profile = Object.freeze({
 			id: profileId ?? "sqlite/default@1",
 			target: "sqlite",
@@ -655,6 +709,10 @@ function renderLimitOffset(keyword, value, ctx) {
 	return `${keyword} ${renderExpr(value, ctx)}`;
 }
 function renderSelect(ast, ctx) {
+	if (ast.locking !== void 0 && ast.locking.length > 0) throw structuredError("RUNTIME.AST_UNSUPPORTED", "SQLite has no row locks, so a select cannot carry a locking clause such as FOR UPDATE", { meta: {
+		target: "sqlite",
+		feature: "locking-clause"
+	} });
 	return [
 		`SELECT ${ast.distinct ? "DISTINCT " : ""}${renderProjection(ast.projection, ctx)}`,
 		ast.from !== void 0 ? `FROM ${renderSource(ast.from, ctx)}` : "",
@@ -662,8 +720,8 @@ function renderSelect(ast, ctx) {
 		ast.where ? `WHERE ${renderExpr(ast.where, ctx)}` : "",
 		ast.groupBy?.length ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, ctx)).join(", ")}` : "",
 		ast.having ? `HAVING ${renderExpr(ast.having, ctx)}` : "",
-		ast.orderBy?.length ? `ORDER BY ${ast.orderBy.map((order) => `${renderExpr(order.expr, ctx)} ${order.dir.toUpperCase()}`).join(", ")}` : "",
-		renderLimitOffset("LIMIT", ast.limit, ctx),
+		ast.orderBy?.length ? `ORDER BY ${renderOrderByItems(ast.orderBy, ctx)}` : "",
+		ast.limit === void 0 && ast.offset !== void 0 ? "LIMIT -1" : renderLimitOffset("LIMIT", ast.limit, ctx),
 		renderLimitOffset("OFFSET", ast.offset, ctx)
 	].filter((part) => part.length > 0).join(" ").trim();
 }
@@ -763,6 +821,7 @@ function renderColumn(ref) {
 }
 function renderLiteral(expr) {
 	if (typeof expr.value === "string") return `'${escapeLiteral(expr.value)}'`;
+	if (typeof expr.value === "number" && !Number.isNaN(expr.value) && !Number.isFinite(expr.value)) return expr.value > 0 ? "9e999" : "-9e999";
 	if (typeof expr.value === "number" || typeof expr.value === "boolean") return String(expr.value);
 	if (typeof expr.value === "bigint") return String(expr.value);
 	if (expr.value === null || expr.value === void 0) return "NULL";
@@ -846,6 +905,8 @@ function renderBinary(expr, ctx) {
 	return `${leftRendered} ${{
 		eq: "=",
 		neq: "!=",
+		isNotDistinctFrom: "IS",
+		isDistinctFrom: "IS NOT",
 		gt: ">",
 		lt: "<",
 		gte: ">=",
@@ -899,7 +960,18 @@ function renderJsonObjectExpr(expr, ctx) {
 	}).join(", ")})`;
 }
 function renderOrderByItems(items, ctx) {
-	return items.map((item) => `${renderExpr(item.expr, ctx)} ${item.dir.toUpperCase()}`).join(", ");
+	return items.map((item) => `${renderExpr(item.expr, ctx)}${ORDER_DIRECTION_SQL[item.dir]}${renderNullsPlacement(item)}`).join(", ");
+}
+const ORDER_DIRECTION_SQL = {
+	asc: " ASC",
+	desc: " DESC"
+};
+const ORDER_NULLS_SQL = {
+	first: " NULLS FIRST",
+	last: " NULLS LAST"
+};
+function renderNullsPlacement(item) {
+	return item.nulls === void 0 ? "" : ORDER_NULLS_SQL[item.nulls];
 }
 function renderJsonArrayAggExpr(expr, ctx) {
 	const aggregateOrderBy = expr.orderBy && expr.orderBy.length > 0 ? ` ORDER BY ${renderOrderByItems(expr.orderBy, ctx)}` : "";
@@ -926,7 +998,7 @@ function renderInsertValue(value, ctx) {
 	}
 }
 function renderInsert(ast, ctx) {
-	const table = qualifyTableFromNamespaceCoordinate(ast.table, ctx);
+	const table = renderTableSource(ast.table, ctx);
 	const rows = ast.rows;
 	const firstRow = rows[0];
 	if (firstRow === void 0) throw structuredError("RUNTIME.AST_INVALID", "INSERT requires at least one row", { meta: {
@@ -954,22 +1026,21 @@ function renderInsert(ast, ctx) {
 	let onConflictClause = "";
 	if (ast.onConflict) {
 		const conflictColumns = ast.onConflict.columns.map((col) => quoteIdentifier(col.column));
-		if (conflictColumns.length === 0) throw structuredError("RUNTIME.AST_INVALID", "INSERT onConflict requires at least one conflict column", { meta: {
-			node: "insert",
-			table: ast.table.name
-		} });
+		const target = conflictColumns.length === 0 ? "" : ` (${conflictColumns.join(", ")})`;
 		const action = ast.onConflict.action;
 		switch (action.kind) {
 			case "do-nothing":
-				onConflictClause = ` ON CONFLICT (${conflictColumns.join(", ")}) DO NOTHING`;
+				onConflictClause = ` ON CONFLICT${target} DO NOTHING`;
 				break;
-			case "do-update-set": {
-				const updates = Object.entries(action.set).map(([colName, value]) => {
+			case "do-update-set":
+				if (conflictColumns.length === 0) throw structuredError("RUNTIME.AST_INVALID", "INSERT onConflict requires at least one conflict column", { meta: {
+					node: "insert",
+					table: ast.table.name
+				} });
+				onConflictClause = ` ON CONFLICT${target} DO UPDATE SET ${Object.entries(action.set).map(([colName, value]) => {
 					return `${quoteIdentifier(colName)} = ${renderExpr(value, ctx)}`;
-				});
-				onConflictClause = ` ON CONFLICT (${conflictColumns.join(", ")}) DO UPDATE SET ${updates.join(", ")}`;
+				}).join(", ")}`;
 				break;
-			}
 			default: assertNever(action, `Unsupported onConflict action: ${unreachableKind(action)}`);
 		}
 	}
@@ -977,7 +1048,7 @@ function renderInsert(ast, ctx) {
 	return `${insertClause}${onConflictClause}${returningClause}`;
 }
 function renderUpdate(ast, ctx) {
-	const table = qualifyTableFromNamespaceCoordinate(ast.table, ctx);
+	const table = renderTableSource(ast.table, ctx);
 	const setClauses = Object.entries(ast.set).map(([col, val]) => {
 		return `${quoteIdentifier(col)} = ${renderExpr(val, ctx)}`;
 	});
@@ -986,13 +1057,13 @@ function renderUpdate(ast, ctx) {
 	return `UPDATE ${table} SET ${setClauses.join(", ")}${whereClause}${returningClause}`;
 }
 function renderDelete(ast, ctx) {
-	return `DELETE FROM ${qualifyTableFromNamespaceCoordinate(ast.table, ctx)}${ast.where ? ` WHERE ${renderExpr(ast.where, ctx)}` : ""}${renderReturning(ast.returning, ctx)}`;
+	return `DELETE FROM ${renderTableSource(ast.table, ctx)}${ast.where ? ` WHERE ${renderExpr(ast.where, ctx)}` : ""}${renderReturning(ast.returning, ctx)}`;
 }
 function renderReturning(returning, ctx) {
 	if (!returning?.length) return "";
 	return ` RETURNING ${returning.map((item) => {
 		if (item.expr.kind === "column-ref") {
-			const rendered = `${quoteIdentifier(item.expr.table)}.${quoteIdentifier(item.expr.column)}`;
+			const rendered = quoteIdentifier(item.expr.column);
 			return item.expr.column === item.alias ? rendered : `${rendered} AS ${quoteIdentifier(item.alias)}`;
 		}
 		return `${renderExpr(item.expr, ctx)} AS ${quoteIdentifier(item.alias)}`;
@@ -1000,12 +1071,12 @@ function renderReturning(returning, ctx) {
 }
 function createSqliteAdapter(options) {
 	const codecRegistry = createSqliteCodecRegistryWithBuiltins(options?.codecDescriptors);
-	return Object.freeze(new SqliteAdapterImpl(codecRegistry, options?.profileId));
+	return Object.freeze(new SqliteAdapterImpl(codecRegistry, sqliteDataTypes, options?.profileId));
 }
-function createSqliteAdapterWithCodecRegistry(codecRegistry) {
-	return Object.freeze(new SqliteAdapterImpl(codecRegistry));
+function createSqliteAdapterWithCodecRegistry(codecRegistry, declaredDataTypes) {
+	return Object.freeze(new SqliteAdapterImpl(codecRegistry, declaredDataTypes));
 }
 //#endregion
-export { createSqliteBuiltinCodecLookup as a, sqliteRawCodecInferer as c, createSqliteAdapterWithCodecRegistry as i, assembleSqliteCodecRegistry as n, createSqliteCodecRegistryWithBuiltins as o, createSqliteAdapter as r, renderLoweredSql as s, SqliteControlAdapter as t };
+export { sqliteRawCodecInferer as a, renderLoweredSql as i, createSqliteAdapter as n, createSqliteAdapterWithCodecRegistry as r, SqliteControlAdapter as t };
 
-//# sourceMappingURL=adapter-CUTKlFpX-CW0J0Qs4.mjs.map
+//# sourceMappingURL=adapter-7m8HU4rt-DN15_Cn8.mjs.map