effect-qb 0.17.0 → 0.20.0

package/src/postgres/type.ts

@@ -1,35 +1,118 @@
 import type * as Expression from "../internal/scalar.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
+import {
+  pickDatatypeConstructors,
+  postgresSpecificDatatypeKeys,
+  type PostgresSpecificDatatypeKey
+} from "../internal/datatypes/matrix.js"
 import { postgresDatatypes } from "./datatypes/index.js"
-import { type as postgresType } from "./internal/dsl.js"
 
-type PostgresTypeNamespace = typeof postgresDatatypes & {
+type PostgresSpecificDatatypes = Pick<typeof postgresDatatypes, PostgresSpecificDatatypeKey>
+
+type PostgresTypeNamespace = PostgresSpecificDatatypes & {
   readonly array: <Element extends Expression.DbType.Any>(
     element: Element
   ) => Expression.DbType.Array<"postgres", Element, `${Element["kind"]}[]`>
   readonly range: <Kind extends string, Subtype extends Expression.DbType.Any>(
-    kind: Kind,
+    kind: NonEmptyStringInput<Kind>,
     subtype: Subtype
   ) => Expression.DbType.Range<"postgres", Subtype, Kind>
   readonly multirange: <Kind extends string, Subtype extends Expression.DbType.Any>(
-    kind: Kind,
+    kind: NonEmptyStringInput<Kind>,
     subtype: Subtype
   ) => Expression.DbType.Multirange<"postgres", Subtype, Kind>
   readonly record: <Kind extends string, Fields extends Record<string, Expression.DbType.Any>>(
-    kind: Kind,
+    kind: NonEmptyStringInput<Kind>,
     fields: Fields
   ) => Expression.DbType.Composite<"postgres", Fields, Kind>
   readonly domain: <Kind extends string, Base extends Expression.DbType.Any>(
-    kind: Kind,
+    kind: NonEmptyStringInput<Kind>,
     base: Base
   ) => Expression.DbType.Domain<"postgres", Base, Kind>
-  readonly enum: <Kind extends string>(kind: Kind) => Expression.DbType.Enum<"postgres", Kind>
-  readonly set: <Kind extends string>(kind: Kind) => Expression.DbType.Set<"postgres", Kind>
-  readonly custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<"postgres", Kind>
+  readonly enum: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Enum<"postgres", Kind>
+  readonly custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<"postgres", Kind>
   readonly driverValueMapping: <Db extends Expression.DbType.Any>(
     dbType: Db,
     mapping: Expression.DriverValueMapping
   ) => Db
 }
 
+const array = <Element extends Expression.DbType.Any>(
+  element: Element
+): Expression.DbType.Array<"postgres", Element, `${Element["kind"]}[]`> => ({
+  dialect: "postgres",
+  kind: `${element.kind}[]`,
+  element
+})
+
+const range = <Kind extends string, Subtype extends Expression.DbType.Any>(
+  kind: NonEmptyStringInput<Kind>,
+  subtype: Subtype
+): Expression.DbType.Range<"postgres", Subtype, Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  subtype
+})
+
+const multirange = <Kind extends string, Subtype extends Expression.DbType.Any>(
+  kind: NonEmptyStringInput<Kind>,
+  subtype: Subtype
+): Expression.DbType.Multirange<"postgres", Subtype, Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  subtype
+})
+
+const record = <Kind extends string, Fields extends Record<string, Expression.DbType.Any>>(
+  kind: NonEmptyStringInput<Kind>,
+  fields: Fields
+): Expression.DbType.Composite<"postgres", Fields, Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  fields
+})
+
+const domain = <Kind extends string, Base extends Expression.DbType.Any>(
+  kind: NonEmptyStringInput<Kind>,
+  base: Base
+): Expression.DbType.Domain<"postgres", Base, Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  base
+})
+
+const enum_ = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Enum<"postgres", Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind,
+  variant: "enum"
+})
+
+const custom = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Base<"postgres", Kind> => ({
+  dialect: "postgres",
+  kind: kind as Kind
+})
+
+const driverValueMapping = <Db extends Expression.DbType.Any>(
+  dbType: Db,
+  mapping: Expression.DriverValueMapping
+): Db => ({
+  ...dbType,
+  driverValueMapping: mapping
+})
+
 /** Postgres database-type constructors for casts and typed column references. */
-export const type: PostgresTypeNamespace = postgresType
+export const type: PostgresTypeNamespace = {
+  ...pickDatatypeConstructors(postgresDatatypes, postgresSpecificDatatypeKeys),
+  array,
+  range,
+  multirange,
+  record,
+  domain,
+  enum: enum_,
+  custom,
+  driverValueMapping
+}

package/src/postgres/unique.ts

@@ -0,0 +1,32 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type UniqueSpec = Extract<TableOptionSpec, { readonly kind: "unique" }>
+
+export const deferrable = <Spec extends UniqueSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly deferrable: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    deferrable: true
+  } as Spec & { readonly deferrable: true }))
+
+export const initiallyDeferred = <Spec extends UniqueSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & {
+  readonly deferrable: true
+  readonly initiallyDeferred: true
+}, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    deferrable: true,
+    initiallyDeferred: true
+  } as Spec & { readonly deferrable: true; readonly initiallyDeferred: true }))
+
+export const nullsNotDistinct = <Spec extends UniqueSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+  option: BaseTable.TableOption<Spec, TableContext>
+): BaseTable.TableOption<Spec & { readonly nullsNotDistinct: true }, TableContext> =>
+  BaseTable.mapOption(option, (spec) => ({
+    ...spec,
+    nullsNotDistinct: true
+  } as Spec & { readonly nullsNotDistinct: true }))

package/src/postgres.ts

@@ -1,23 +1,19 @@
-/** Postgres-specialized column-definition DSL. */
-export * as Column from "./postgres/column.js"
+/** Postgres-specific column extensions. Portable columns are exported from `effect-qb`. */
+export * as Column from "./postgres/column-extension.js"
 /** Postgres datatype witnesses and coercion families. */
 export * as Datatypes from "./postgres/datatypes/index.js"
 /** Postgres SQLSTATE catalog and error normalization helpers. */
 export * as Errors from "./postgres/errors/index.js"
-/** Shared scalar SQL interfaces and DB-type descriptors. */
-export * as Scalar from "./internal/scalar.js"
-/** Postgres cast helpers. */
-export { cast as Cast } from "./postgres/cast.js"
-/** Postgres-specialized SQL function expressions. */
+/** Postgres-specific SQL function expressions. Portable functions are exported from the root package. */
 export * as Function from "./postgres/function/index.js"
-/** Postgres-specialized JSON expression helpers. */
-export * as Json from "./postgres/json.js"
+/** Postgres-specific JSON expression helpers. Portable JSON helpers are exported from the root package. */
+export * as Json from "./postgres/json-extension.js"
+/** Postgres jsonb-only expression helpers. */
+export * as Jsonb from "./postgres/jsonb.js"
 /** Postgres-specialized typed query execution contracts. */
 export * as Executor from "./postgres/executor.js"
-/** Shared logical row-set interfaces. */
-export * as RowSet from "./internal/row-set.js"
-/** Postgres-specialized query-construction DSL. */
-export * as Query from "./postgres/query.js"
+/** Postgres-specific query helpers. Portable queries are exported from the root package. */
+export * as Query from "./postgres/query-extension.js"
 /** Postgres database-type constructors for casts and typed references. */
 export { type as Type } from "./postgres/type.js"
 /** Postgres normalized table/enum metadata helpers. */
@@ -25,12 +21,20 @@ export * as Metadata from "./postgres/metadata.js"
 /** Postgres schema-expression helpers for DDL-only metadata. */
 export * as SchemaExpression from "./postgres/schema-expression.js"
 /** Postgres schema-scoped table and enum builder helpers. */
-export { schema } from "./postgres/schema.js"
+export * as Schema from "./postgres/schema.js"
 export type { SchemaNamespace } from "./postgres/schema.js"
 /** Postgres enum and sequence definition helpers. */
 export { enumType as enum, sequence } from "./postgres/schema-management.js"
 export type { EnumDefinition, SequenceDefinition } from "./postgres/schema-management.js"
-/** Postgres-specialized table-definition DSL. */
-export * as Table from "./postgres/table.js"
+/** Postgres-specific primary-key option modifiers. */
+export * as PrimaryKey from "./postgres/primary-key.js"
+/** Postgres-specific unique-constraint option modifiers. */
+export * as Unique from "./postgres/unique.js"
+/** Postgres-specific index option modifiers. */
+export * as Index from "./postgres/index.js"
+/** Postgres-specific foreign-key option modifiers. */
+export * as ForeignKey from "./postgres/foreign-key.js"
+/** Postgres-specific check-constraint option modifiers. */
+export * as Check from "./postgres/check.js"
 /** Postgres-specialized built-in renderer entrypoint. */
 export * as Renderer from "./postgres/renderer.js"

package/src/sqlite/column-extension.ts

@@ -0,0 +1,3 @@
+export { custom } from "./column.js"
+
+export type { Any, AnyBound } from "./column.js"

package/src/sqlite/column.ts

@@ -3,6 +3,8 @@ import * as Schema from "effect/Schema"
 import * as BaseColumn from "../internal/column.js"
 import { makeColumnDefinition, type AnyColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
 import type * as Expression from "../internal/scalar.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
+import { enrichDbType } from "../internal/datatypes/enrich.js"
 import {
   DecimalStringSchema,
   LocalDateStringSchema,
@@ -15,15 +17,8 @@ import {
 } from "../internal/runtime/value.js"
 import { sqliteDatatypes } from "./datatypes/index.js"
 
-const enrichDbType = <Db extends Expression.DbType.Any>(dbType: Db): Db => {
-  const candidate = (sqliteDatatypes as unknown as Record<string, (() => Expression.DbType.Any) | undefined>)[dbType.kind]
-  return typeof candidate === "function"
-    ? { ...candidate(), ...dbType } as Db
-    : dbType
-}
-
 const primitive = <Type, Db extends Expression.DbType.Any>(
-  schema: Schema.Schema<Type, any, any>,
+  schema: Schema.Schema<Type>,
   dbType: Db
 ): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
   makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
@@ -48,12 +43,12 @@ const renderNumericDdlType = (
     : `${kind}(${options.precision},${options.scale})`
 }
 
-export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+export const custom = <SchemaType extends Schema.Top, Db extends Expression.DbType.Any>(
   schema: SchemaType,
   dbType: Db
 ) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
-    dbType: enrichDbType(dbType),
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
+    dbType: enrichDbType(sqliteDatatypes, dbType),
     nullable: false,
     hasDefault: false,
     generated: false,
@@ -64,7 +59,7 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
     identity: undefined
   })
 
-export const uuid = () => primitive(Schema.UUID, sqliteDatatypes.uuid())
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), sqliteDatatypes.uuid())
 export const text = () => primitive(Schema.String, sqliteDatatypes.text())
 export const int = () => primitive(Schema.Int, sqliteDatatypes.int())
 export const number = (options?: BaseColumn.NumericOptions) =>
@@ -84,8 +79,8 @@ export const date = () => primitive(LocalDateStringSchema, sqliteDatatypes.date(
 export const time = () => primitive(LocalTimeStringSchema, sqliteDatatypes.time())
 export const datetime = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.datetime())
 export const timestamp = () => primitive(LocalDateTimeStringSchema, sqliteDatatypes.timestamp())
-export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+export const json = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: { ...sqliteDatatypes.json(), variant: "json" } as Expression.DbType.Json<"sqlite", "json">,
     nullable: false,
     hasDefault: false,
@@ -109,10 +104,14 @@ type SqliteUniqueOptions = {
   readonly initiallyDeferred?: never
 }
 
+type NonEmptyOptionNameInput<Options> = Options extends { readonly name: infer Name extends string }
+  ? NonEmptyStringInput<Name> extends never ? never : unknown
+  : unknown
+
 type UniqueModifier = {
   <Column extends AnyColumnDefinition>(column: Column): UniqueColumn<Column>
   readonly options: <const Options extends SqliteUniqueOptions>(
-    options: Options
+    options: Options & NonEmptyOptionNameInput<Options>
   ) => <Column extends AnyColumnDefinition>(column: Column) => UniqueColumn<Column>
 }
 

package/src/sqlite/datatypes/index.ts

@@ -1,5 +1,6 @@
 import type { DatatypeModule } from "../../internal/datatypes/define.js"
 import type * as Expression from "../../internal/scalar.js"
+import type { NonEmptyStringInput } from "../../internal/table-options.js"
 import { sqliteDatatypeFamilies, sqliteDatatypeKinds } from "./spec.js"
 
 const withMetadata = <Kind extends keyof typeof sqliteDatatypeKinds & string>(
@@ -14,14 +15,15 @@ const withMetadata = <Kind extends keyof typeof sqliteDatatypeKinds & string>(
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: (familySpec as { readonly implicitTargets?: readonly string[] }).implicitTargets,
     traits: familySpec?.traits
   }
 }
 
 const sqliteDatatypeModule = {
-  custom: (kind: string) => ({
+  custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => ({
     dialect: "sqlite",
-    kind
+    kind: kind as Kind
   }),
   uuid: () => ({
     dialect: "sqlite",

package/src/sqlite/datatypes/spec.ts

@@ -1,98 +1,10 @@
-import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+import {
+  sqliteDatatypeFamilies as matrixSqliteDatatypeFamilies,
+  sqliteDatatypeKinds as matrixSqliteDatatypeKinds
+} from "../../internal/datatypes/matrix.js"
 
-export const sqliteDatatypeFamilies = {
-  text: {
-    compareGroup: "text",
-    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  numeric: {
-    compareGroup: "numeric",
-    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
-    traits: {
-      ordered: true
-    }
-  },
-  integer: {
-    compareGroup: "numeric",
-    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
-    traits: {
-      ordered: true
-    }
-  },
-  real: {
-    compareGroup: "numeric",
-    castTargets: ["real", "numeric", "integer", "text", "boolean"],
-    traits: {
-      ordered: true
-    }
-  },
-  boolean: {
-    compareGroup: "boolean",
-    castTargets: ["boolean", "integer", "numeric", "text"],
-    traits: {}
-  },
-  date: {
-    compareGroup: "date",
-    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  time: {
-    compareGroup: "time",
-    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  datetime: {
-    compareGroup: "datetime",
-    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
-    traits: {
-      ordered: true
-    }
-  },
-  json: {
-    compareGroup: "json",
-    castTargets: ["json", "text"],
-    traits: {}
-  },
-  blob: {
-    compareGroup: "blob",
-    castTargets: ["blob", "text"],
-    traits: {}
-  },
-  null: {
-    compareGroup: "null",
-    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
-    traits: {}
-  }
-} as const satisfies Record<string, DatatypeFamilySpec>
-
-export const sqliteDatatypeKinds = {
-  text: { family: "text", runtime: "string" },
-  varchar: { family: "text", runtime: "string" },
-  char: { family: "text", runtime: "string" },
-  clob: { family: "text", runtime: "string" },
-  int: { family: "integer", runtime: "number" },
-  integer: { family: "integer", runtime: "number" },
-  bigint: { family: "integer", runtime: "bigintString" },
-  numeric: { family: "numeric", runtime: "decimalString" },
-  decimal: { family: "numeric", runtime: "decimalString" },
-  real: { family: "real", runtime: "number" },
-  double: { family: "real", runtime: "number" },
-  boolean: { family: "boolean", runtime: "boolean" },
-  date: { family: "date", runtime: "localDate" },
-  time: { family: "time", runtime: "localTime" },
-  datetime: { family: "datetime", runtime: "localDateTime" },
-  timestamp: { family: "datetime", runtime: "localDateTime" },
-  json: { family: "json", runtime: "json" },
-  blob: { family: "blob", runtime: "bytes" }
-} as const satisfies Record<string, DatatypeKindSpec>
+export const sqliteDatatypeFamilies = matrixSqliteDatatypeFamilies
+export const sqliteDatatypeKinds = matrixSqliteDatatypeKinds
 
 export type SqliteDatatypeFamily = keyof typeof sqliteDatatypeFamilies
 export type SqliteDatatypeKind = keyof typeof sqliteDatatypeKinds

package/src/sqlite/errors/normalize.ts

@@ -25,7 +25,6 @@ const unwrapSqliteDriverCause = (cause: unknown): unknown => {
   while (
     isRecord(current) &&
     "_tag" in current &&
-    current._tag === "SqlError" &&
     "cause" in current
   ) {
     current = current.cause

package/src/sqlite/executor.ts

@@ -1,11 +1,12 @@
 import * as Effect from "effect/Effect"
-import * as SqlClient from "@effect/sql/SqlClient"
+import * as SqlClient from "effect/unstable/sql/SqlClient"
 import * as Stream from "effect/Stream"
 
 import * as CoreExecutor from "../internal/executor.js"
 import * as CoreQuery from "../internal/query.js"
 import * as CoreRenderer from "../internal/renderer.js"
 import type * as Expression from "../internal/scalar.js"
+import type { SqliteDatatypeFamily, SqliteDatatypeKind } from "./datatypes/spec.js"
 import { renderSqlitePlan } from "./internal/renderer.js"
 import {
   narrowSqliteDriverErrorForReadQuery,
@@ -24,12 +25,13 @@ export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"sqlite
 export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"sqlite", Error, Context>
 /** SQLite-specialized renderer contract. */
 export type Renderer = CoreRenderer.Renderer<"sqlite">
+export type ValueMappings = Expression.DriverValueMappingsFor<SqliteDatatypeKind | "uuid", SqliteDatatypeFamily | "uuid">
 /** Optional renderer / driver overrides for the standard SQLite executor pipeline. */
 export interface MakeOptions<Error = never, Context = never> {
   readonly renderer?: Renderer
   readonly driver?: Driver<Error, Context>
   readonly driverMode?: CoreExecutor.DriverMode
-  readonly valueMappings?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
 }
 /** Standard composed error shape for SQLite executors. */
 export type SqliteExecutorError = SqliteDriverError | RowDecodeError
@@ -39,8 +41,6 @@ export type SqliteQueryError<PlanValue extends CoreQuery.QueryPlan<any, any, any
 
 /** Runs an effect within the ambient SQLite SQL transaction service. */
 export const withTransaction = CoreExecutor.withTransaction
-/** Runs an effect in a nested SQLite SQL transaction scope. */
-export const withSavepoint = CoreExecutor.withSavepoint
 
 /** SQLite executor whose error channel narrows based on the query plan. */
 export interface QueryExecutor<Context = never> {
@@ -140,10 +140,10 @@ const fromDriver = <
   stream(plan) {
     const rendered = renderer.render(plan)
     return Stream.mapError(
-      Stream.mapChunksEffect(
+      Stream.mapArrayEffect(
         sqlDriver.stream(rendered),
         (rows) => Effect.try({
-          try: () => CoreExecutor.decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }) as never,
           catch: (error) => error as RowDecodeError
         })
       ),
@@ -179,21 +179,21 @@ const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
  * Creates the standard SQLite executor pipeline.
  *
  * By default this uses the built-in SQLite renderer plus the ambient
- * `@effect/sql` `SqlClient`. Advanced callers can override the renderer,
+ * `effect/unstable/sql` `SqlClient`. Advanced callers can override the renderer,
  * driver, or both.
  */
 export function make(): QueryExecutor<SqlClient.SqlClient>
 export function make(options: {
   readonly renderer?: Renderer
   readonly driverMode?: CoreExecutor.DriverMode
-  readonly valueMappings?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
 }): QueryExecutor<SqlClient.SqlClient>
 export function make<Error = never, Context = never>(
   options: {
     readonly renderer?: Renderer
     readonly driver: Driver<Error, Context>
     readonly driverMode?: CoreExecutor.DriverMode
-    readonly valueMappings?: Expression.DriverValueMappings
+    readonly valueMappings?: ValueMappings
   }
 ): QueryExecutor<Context>
 export function make<Error = never, Context = never>(
@@ -201,14 +201,14 @@ export function make<Error = never, Context = never>(
 ): QueryExecutor<any> {
   if (options.driver) {
     return fromDriver(
-      options.renderer ?? CoreRenderer.make("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options.valueMappings })),
+      options.renderer ?? CoreRenderer.makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options.valueMappings })),
       options.driver,
       options.driverMode,
       options.valueMappings
     )
   }
   return fromDriver(
-    options.renderer ?? CoreRenderer.make("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options.valueMappings })),
+    options.renderer ?? CoreRenderer.makeTrusted("sqlite", (plan) => renderSqlitePlan(plan, { valueMappings: options.valueMappings })),
     sqlClientDriver(),
     options.driverMode,
     options.valueMappings

package/src/sqlite/function/temporal.ts

@@ -35,7 +35,7 @@ const makeTemporal = <
 >(
   name: Name,
   dbType: Db,
-  runtimeSchema: Schema.Schema<Runtime, any, any>
+  runtimeSchema: Schema.Schema<Runtime>
 ): TemporalExpression<Runtime, Db, Name> =>
   makeExpression({
     runtime: undefined as unknown as Runtime,

package/src/sqlite/internal/dialect.ts

@@ -1,7 +1,9 @@
-import type { RenderState, RenderValueContext, SqlDialect } from "../../internal/dialect.js"
+import { quoteDoubleQuotedIdentifier, type RenderState, type RenderValueContext, type SqlDialect } from "../../internal/dialect.js"
+import { renderExpression, renderQueryAst } from "../../internal/dialect-renderers/sqlite.js"
 import { toDriverValue } from "../../internal/runtime/driver-value-mapping.js"
+import { standardDialect } from "../../standard/dialect.js"
 
-const quoteIdentifier = (value: string): string => `"${value.replaceAll("\"", "\"\"")}"`
+const quoteIdentifier = quoteDoubleQuotedIdentifier
 
 const renderLiteral = (value: unknown, state: RenderState, context: RenderValueContext = {}): string => {
   const driverValue = toDriverValue(value, {
@@ -20,11 +22,12 @@ const renderLiteral = (value: unknown, state: RenderState, context: RenderValueC
  * Built-in runtime dialect implementation for SQLite.
  */
 export const sqliteDialect: SqlDialect<"sqlite"> = {
+  ...standardDialect,
   name: "sqlite",
   quoteIdentifier,
   renderLiteral,
   renderTableReference(tableName, baseTableName, schemaName) {
-    const renderedBase = schemaName
+    const renderedBase = schemaName && schemaName !== "public"
       ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
       : quoteIdentifier(baseTableName)
     return tableName === baseTableName
@@ -33,5 +36,7 @@ export const sqliteDialect: SqlDialect<"sqlite"> = {
   },
   renderConcat(values) {
     return `(${values.join(" || ")})`
-  }
+  },
+  renderQueryAst,
+  renderExpression
 }