effect-qb 0.17.0 → 0.19.0

package/src/internal/dsl-transaction-ddl-runtime.ts

@@ -1,5 +1,4 @@
 import * as Plan from "./row-set.js"
-import * as Table from "./table.js"
 
 type DslTransactionDdlRuntimeContext = {
   readonly profile: {
@@ -11,16 +10,13 @@ type DslTransactionDdlRuntimeContext = {
   readonly defaultIndexName: (tableName: string, columns: readonly string[], unique: boolean) => string
 }
 
-const allowedIsolationLevels = new Set(["read committed", "repeatable read", "serializable"])
-
-export const renderTransactionIsolationLevel = (isolationLevel: unknown): string => {
+export const renderTransactionIsolationLevel = (
+  isolationLevel: unknown
+): string => {
   if (isolationLevel === undefined) {
     return ""
   }
-  if (typeof isolationLevel !== "string" || !allowedIsolationLevels.has(isolationLevel)) {
-    throw new Error("Unsupported transaction isolation level")
-  }
-  return `isolation level ${isolationLevel}`
+  return `isolation level ${isolationLevel as string}`
 }
 
 export const expectDdlClauseKind = <
@@ -28,53 +24,29 @@ export const expectDdlClauseKind = <
   Kind extends Ddl["kind"]
 >(
   ddl: Ddl | undefined,
-  kind: Kind
-): Extract<Ddl, { readonly kind: Kind }> => {
-  if (ddl === undefined || ddl.kind !== kind) {
-    throw new Error("Unsupported DDL statement kind")
-  }
-  return ddl as Extract<Ddl, { readonly kind: Kind }>
-}
+  _kind: Kind
+): Extract<Ddl, { readonly kind: Kind }> =>
+  ddl as Extract<Ddl, { readonly kind: Kind }>
 
 export const expectTruncateClause = <
   Truncate extends { readonly kind: string }
 >(
   truncate: Truncate | undefined
-): Extract<Truncate, { readonly kind: "truncate" }> => {
-  if (truncate === undefined || truncate.kind !== "truncate") {
-    throw new Error("Unsupported truncate statement kind")
-  }
-  return truncate as Extract<Truncate, { readonly kind: "truncate" }>
-}
+): Extract<Truncate, { readonly kind: "truncate" }> =>
+  truncate as Extract<Truncate, { readonly kind: "truncate" }>
 
-const validateIsolationLevel = (isolationLevel: unknown): void => {
-  renderTransactionIsolationLevel(isolationLevel)
-}
-
-export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContext) => {
-  const isRecord = (value: unknown): value is Record<PropertyKey, unknown> =>
-    typeof value === "object" && value !== null
-
-  const assertTableTarget = (target: unknown, apiName: string): void => {
-    if (!isRecord(target) || !(Table.TypeId in target) || !(Plan.TypeId in target)) {
-      throw new Error(`${apiName}(...) requires a table target`)
-    }
-  }
+export const normalizeStatementFlag = (value: unknown): boolean =>
+  (value as boolean | undefined) ?? false
 
-  const validateIndexColumns = (target: any, columns: readonly string[]): void => {
-    const fields = target[Table.TypeId]?.fields as Record<string, unknown> | undefined
-    if (fields === undefined) {
-      return
-    }
-    for (const columnName of columns) {
-      if (!(columnName in fields)) {
-        throw new Error(`effect-qb: unknown index column '${columnName}'`)
-      }
-    }
-  }
+export const normalizeStatementIdentifier = (
+  _apiName: string,
+  _identifierName: string,
+  value: unknown
+): string =>
+  value as string
 
+export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContext) => {
   const transaction = (options: { readonly isolationLevel?: any; readonly readOnly?: boolean } = {}) => {
-    validateIsolationLevel(options.isolationLevel)
     return ctx.makePlan({
       selection: {},
       required: [],
@@ -134,8 +106,8 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       orderBy: []
     }, undefined, "transaction", "rollback")
 
-  const savepoint = (name: string) =>
-    ctx.makePlan({
+  const savepoint = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -153,9 +125,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "savepoint")
+  }
 
-  const rollbackTo = (name: string) =>
-    ctx.makePlan({
+  const rollbackTo = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -173,9 +146,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "rollbackTo")
+  }
 
-  const releaseSavepoint = (name: string) =>
-    ctx.makePlan({
+  const releaseSavepoint = (name: string) => {
+    return ctx.makePlan({
       selection: {},
       required: [],
       available: {},
@@ -193,9 +167,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       groupBy: [],
       orderBy: []
     }, undefined, "transaction", "releaseSavepoint")
+  }
 
   const createTable = (target: any, options: { readonly ifNotExists?: boolean } = {}) => {
-    assertTableTarget(target, "createTable")
+    const ifNotExists = normalizeStatementFlag(options.ifNotExists)
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -213,7 +188,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "createTable",
-        ifNotExists: options.ifNotExists ?? false
+        ifNotExists
       },
       where: [],
       having: [],
@@ -224,7 +199,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
   }
 
   const dropTable = (target: any, options: { readonly ifExists?: boolean } = {}) => {
-    assertTableTarget(target, "dropTable")
+    const ifExists = normalizeStatementFlag(options.ifExists)
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -242,7 +217,7 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "dropTable",
-        ifExists: options.ifExists ?? false
+        ifExists
       },
       where: [],
       having: [],
@@ -253,9 +228,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
   }
 
   const createIndex = (target: any, columns: string | readonly string[], options: { readonly name?: string; readonly unique?: boolean; readonly ifNotExists?: boolean } = {}) => {
-    assertTableTarget(target, "createIndex")
     const normalizedColumns = ctx.normalizeColumnList(columns)
-    validateIndexColumns(target, normalizedColumns)
+    const unique = normalizeStatementFlag(options.unique)
+    const ifNotExists = normalizeStatementFlag(options.ifNotExists)
+    const name = options.name
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -273,10 +249,10 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "createIndex",
-        name: options.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, options.unique ?? false),
+        name: name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, unique),
         columns: normalizedColumns,
-        unique: options.unique ?? false,
-        ifNotExists: options.ifNotExists ?? false
+        unique,
+        ifNotExists
       },
       where: [],
       having: [],
@@ -287,9 +263,9 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
   }
 
   const dropIndex = (target: any, columns: string | readonly string[], options: { readonly name?: string; readonly ifExists?: boolean } = {}) => {
-    assertTableTarget(target, "dropIndex")
     const normalizedColumns = ctx.normalizeColumnList(columns)
-    validateIndexColumns(target, normalizedColumns)
+    const ifExists = normalizeStatementFlag(options.ifExists)
+    const name = options.name
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target)
     return ctx.makePlan({
       selection: {},
@@ -307,8 +283,8 @@ export const makeDslTransactionDdlRuntime = (ctx: DslTransactionDdlRuntimeContex
       },
       ddl: {
         kind: "dropIndex",
-        name: options.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
-        ifExists: options.ifExists ?? false
+        name: name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
+        ifExists
       },
       where: [],
       having: [],

package/src/internal/executor.ts

@@ -509,24 +509,28 @@ export const fromDriver = <
   renderer: Renderer.Renderer<Dialect>,
   sqlDriver: Driver<Dialect, Error, Context>
 ): Executor<Dialect, Error, Context> => {
-  const executor = {
+  const executor: Executor<Dialect, Error, Context> = {
     dialect: renderer.dialect,
-    execute(plan: any) {
+    execute<PlanValue extends Query.Plan.Any>(
+      plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
+    ) {
       const rendered = renderer.render(plan) as Renderer.RenderedQuery<any, Dialect>
       return Effect.map(
         sqlDriver.execute(rendered),
         (rows) => remapRows<any>(rendered, rows)
-      )
+      ) as Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
     },
-    stream(plan: any) {
+    stream<PlanValue extends Query.Plan.Any>(
+      plan: Query.DialectCompatiblePlan<PlanValue, Dialect>
+    ) {
       const rendered = renderer.render(plan) as Renderer.RenderedQuery<any, Dialect>
       return Stream.mapChunks(
         sqlDriver.stream(rendered),
         (rows) => Chunk.unsafeFromArray(remapRows<any>(rendered, Chunk.toReadonlyArray(rows)))
-      )
+      ) as Stream.Stream<Query.ResultRow<PlanValue>, Error, Context>
     }
   }
-  return executor as unknown as Executor<Dialect, Error, Context>
+  return executor
 }
 
 export const streamFromSqlClient = <Dialect extends string>(

package/src/internal/grouping-key.ts

@@ -21,7 +21,9 @@ const subqueryPlanGroupingKey = (plan: unknown): string => {
 
 const literalGroupingKey = (value: unknown): string => {
   if (value instanceof Date) {
-    return `date:${value.toISOString()}`
+    return Number.isNaN(value.getTime())
+      ? "date:invalid"
+      : `date:${value.toISOString()}`
   }
   if (value === null) {
     return "null"
@@ -44,6 +46,30 @@ const isExpression = (value: unknown): value is Expression.Any =>
 const expressionGroupingKey = (value: unknown): string =>
   isExpression(value) ? groupingKeyOfExpression(value) : "missing"
 
+const requiredExpressionGroupingKey = (
+  _functionName: string,
+  value: unknown
+): string => groupingKeyOfExpression(value as Expression.Any)
+
+const requiredBinaryExpressionGroupingKey = (
+  _functionName: string,
+  left: unknown,
+  right: unknown
+): string => `${groupingKeyOfExpression(left as Expression.Any)},${groupingKeyOfExpression(right as Expression.Any)}`
+
+const functionCallArgsGroupingKey = (args: unknown): string =>
+  (args as readonly Expression.Any[]).map(groupingKeyOfExpression).join(",")
+
+const variadicGroupingKey = (
+  _functionName: string,
+  values: unknown
+): string => (values as readonly Expression.Any[]).map(groupingKeyOfExpression).join(",")
+
+const castTargetGroupingKey = (target: unknown): string => {
+  const typed = target as { readonly dialect?: string; readonly kind?: string } | null | undefined
+  return `${typed?.dialect}:${typed?.kind}`
+}
+
 const escapeGroupingText = (value: string): string =>
   value
     .replace(/\\/g, "\\\\")
@@ -52,6 +78,30 @@ const escapeGroupingText = (value: string): string =>
     .replace(/=/g, "\\=")
     .replace(/>/g, "\\>")
 
+const functionCallNameGroupingKey = (name: unknown): string =>
+  escapeGroupingText(name as string)
+
+const quantifiedComparisonGroupingName = (
+  kind: "comparisonAny" | "comparisonAll"
+): "compareAny" | "compareAll" =>
+  kind === "comparisonAny" ? "compareAny" : "compareAll"
+
+const caseGroupingKey = (
+  branches: unknown,
+  fallback: unknown
+): string => {
+  const typedBranches = branches as readonly ExpressionAst.CaseBranchNode[]
+  return `case(${typedBranches.map((branch) =>
+    `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(fallback as Expression.Any)})`
+}
+
+const collationGroupingKey = (collation: unknown): string => {
+  if (Array.isArray(collation)) {
+    return collation.map((part) => escapeGroupingText(String(part))).join(",")
+  }
+  return escapeGroupingText(String(collation))
+}
+
 const jsonSegmentGroupingKey = (segment: unknown): string => {
   if (segment !== null && typeof segment === "object" && "kind" in segment) {
     switch ((segment as { readonly kind: string }).kind) {
@@ -78,8 +128,15 @@ const jsonSegmentGroupingKey = (segment: unknown): string => {
   return "unknown"
 }
 
-const jsonPathGroupingKey = (segments: readonly unknown[] | undefined): string =>
-  (segments ?? []).map(jsonSegmentGroupingKey).join(",")
+const jsonPathGroupingKey = (segments: unknown): string => {
+  if (segments === undefined) {
+    return ""
+  }
+  if (!Array.isArray(segments)) {
+    return "unknown"
+  }
+  return segments.map(jsonSegmentGroupingKey).join(",")
+}
 
 const isJsonPath = (value: unknown): value is JsonPath.Path =>
   value !== null && typeof value === "object" && JsonPath.TypeId in value
@@ -97,9 +154,20 @@ const jsonOpaquePathGroupingKey = (value: unknown): string => {
   return "jsonpath:unknown"
 }
 
-const jsonEntryGroupingKey = (
-  entry: { readonly key: string; readonly value: Expression.Any }
-): string => `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`
+const jsonKeysGroupingKey = (keys: unknown): string => {
+  if (!Array.isArray(keys) || keys.length === 0) {
+    return ""
+  }
+  return keys.map((key) => escapeGroupingText(String(key))).join(",")
+}
+
+const jsonBuildObjectGroupingKey = (entries: unknown): string => {
+  return (entries as readonly { readonly key: string; readonly value: Expression.Any }[]).map((entry) =>
+    `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`).join("|")
+}
+
+const jsonBuildArrayGroupingKey = (values: unknown): string =>
+  (values as readonly Expression.Any[]).map(groupingKeyOfExpression).join(",")
 
 export const groupingKeyOfExpression = (expression: Expression.Any): string => {
   const ast = (expression as Expression.Any & {
@@ -111,11 +179,11 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "literal":
       return `literal:${literalGroupingKey(ast.value)}`
     case "cast":
-      return `cast(${groupingKeyOfExpression(ast.value)} as ${ast.target.dialect}:${ast.target.kind})`
+      return `cast(${requiredExpressionGroupingKey("cast", ast.value)} as ${castTargetGroupingKey(ast.target)})`
     case "collate":
-      return `collate(${groupingKeyOfExpression(ast.value)},${ast.collation.map(escapeGroupingText).join(",")})`
+      return `collate(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`
     case "function":
-      return `function(${escapeGroupingText(ast.name)},${ast.args.map(groupingKeyOfExpression).join(",")})`
+      return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`
     case "isNull":
     case "isNotNull":
     case "not":
@@ -124,7 +192,7 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "count":
     case "max":
     case "min":
-      return `${ast.kind}(${groupingKeyOfExpression(ast.value)})`
+      return `${ast.kind}(${requiredExpressionGroupingKey(ast.kind, ast.value)})`
     case "eq":
     case "neq":
     case "lt":
@@ -142,7 +210,7 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "contains":
     case "containedBy":
     case "overlaps":
-      return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`
+      return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`
     case "and":
     case "or":
     case "coalesce":
@@ -150,19 +218,18 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "in":
     case "notIn":
     case "between":
-      return `${ast.kind}(${ast.values.map(groupingKeyOfExpression).join(",")})`
+      return `${ast.kind}(${variadicGroupingKey(ast.kind, ast.values)})`
     case "case":
-      return `case(${ast.branches.map((branch: ExpressionAst.CaseBranchNode) =>
-        `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(ast.else)})`
+      return caseGroupingKey(ast.branches, ast.else)
     case "exists":
       return `exists(${subqueryPlanGroupingKey(ast.plan)})`
     case "scalarSubquery":
       return `scalarSubquery(${subqueryPlanGroupingKey(ast.plan)})`
     case "inSubquery":
-      return `inSubquery(${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
+      return `inSubquery(${requiredExpressionGroupingKey("inSubquery", ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
     case "comparisonAny":
     case "comparisonAll":
-      return `${ast.kind}(${ast.operator},${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
+      return `${ast.kind}(${ast.operator},${requiredExpressionGroupingKey(quantifiedComparisonGroupingName(ast.kind), ast.left)},${subqueryPlanGroupingKey(ast.plan)})`
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
@@ -176,7 +243,7 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys":
-      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${(ast.keys ?? []).map(escapeGroupingText).join(",")})`
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonKeysGroupingKey(ast.keys)})`
     case "jsonConcat":
     case "jsonMerge":
       return `json(${ast.kind},${expressionGroupingKey(ast.left)},${expressionGroupingKey(ast.right)},)`
@@ -192,9 +259,9 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "jsonPathMatch":
       return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonOpaquePathGroupingKey(ast.query)})`
     case "jsonBuildObject":
-      return `json(${ast.kind},${(ast.entries ?? []).map(jsonEntryGroupingKey).join("|")})`
+      return `json(${ast.kind},${jsonBuildObjectGroupingKey(ast.entries)})`
     case "jsonBuildArray":
-      return `json(${ast.kind},${(ast.values ?? []).map(groupingKeyOfExpression).join(",")})`
+      return `json(${ast.kind},${jsonBuildArrayGroupingKey(ast.values)})`
     case "jsonToJson":
     case "jsonToJsonb":
     case "jsonTypeOf":
@@ -203,7 +270,7 @@ export const groupingKeyOfExpression = (expression: Expression.Any): string => {
     case "jsonStripNulls":
       return `json(${ast.kind},${expressionGroupingKey(ast.value)})`
     default:
-      throw new Error("Unsupported expression for grouping key generation")
+      return `unknown:${typeof ast === "object" && ast !== null && "kind" in ast ? String((ast as { readonly kind: unknown }).kind) : "ast"}`
   }
 }
 

package/src/internal/implication-runtime.ts

@@ -41,7 +41,7 @@ const collectPresenceWitnesses = (
     return
   }
   if (Expression.TypeId in selection && ExpressionAst.TypeId in selection) {
-    const expression = selection as unknown as AstBackedExpression
+    const expression = selection as AstBackedExpression
     const ast = expression[ExpressionAst.TypeId]
     if (ast.kind === "column" && expression[Expression.TypeId].nullability === "never") {
       output.add(columnPredicateKey(ast.tableName, ast.columnName))

package/src/internal/predicate/runtime.ts

@@ -474,6 +474,9 @@ const valueKeyOfLiteral = (value: unknown): string => {
     return "null"
   }
   if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new Error("Expected a valid Date value")
+    }
     return `date:${value.toISOString()}`
   }
   return "unknown"

package/src/internal/query.d.ts

@@ -37,6 +37,31 @@ export interface QueryState<Outstanding extends string, AvailableNames extends s
 }
 /** Effective SQL dialect carried by an expression. */
 export type DialectOf<Value extends Expression.Any> = Value[typeof Expression.TypeId]["dialect"];
+type ConcreteDialect<D> = D extends "standard" ? never : D;
+type IsDialectUnion<Union, All = Union> = Union extends any ? [
+    All
+] extends [Union] ? false : true : false;
+export type DialectConflictError<A extends string, B extends string> = string & {
+    readonly _tag: "DialectConflict";
+    readonly left: A;
+    readonly right: B;
+};
+export type MergeDialect<A extends string, B extends string> = [
+    ConcreteDialect<A>,
+    ConcreteDialect<B>
+] extends [never, never] ? "standard" : [
+    ConcreteDialect<A>,
+    ConcreteDialect<B>
+] extends [never, infer C extends string] ? C : [
+    ConcreteDialect<A>,
+    ConcreteDialect<B>
+] extends [infer C extends string, never] ? C : ConcreteDialect<A> extends ConcreteDialect<B> ? ConcreteDialect<B> extends ConcreteDialect<A> ? A : DialectConflictError<A, B> : DialectConflictError<A, B>;
+/** Collapses the portable standard tag out of a dialect union. */
+export type NormalizeDialect<Dialect extends string> = [
+    Dialect
+] extends [never] ? never : [
+    Exclude<Dialect, "standard">
+] extends [never] ? "standard" : IsDialectUnion<Exclude<Dialect, "standard">> extends true ? DialectConflictError<Exclude<Dialect, "standard">, Exclude<Dialect, "standard">> : Exclude<Dialect, "standard">;
 /** Source dependency union carried by an expression. */
 export type DependenciesOf<Value extends Expression.Any> = Expression.DependenciesOf<Value>;
 /** Aggregation kind carried by an expression. */
@@ -135,10 +160,11 @@ export type SelectionShape = Expression.Any | {
 export type ExtractRequired<Selection> = Selection extends Expression.Any ? RequiredFromDependencies<DependenciesOf<Selection>> : Selection extends Record<string, any> ? {
     [K in keyof Selection]: ExtractRequired<Selection[K]>;
 }[keyof Selection] : never;
-/** Walks a selection tree and unions the dialects referenced by its leaves. */
-export type ExtractDialect<Selection> = Selection extends Expression.Any ? DialectOf<Selection> : Selection extends Record<string, any> ? {
-    [K in keyof Selection]: ExtractDialect<Selection[K]>;
+type ExtractDialectRaw<Selection> = Selection extends Expression.Any ? DialectOf<Selection> : Selection extends Record<string, any> ? {
+    [K in keyof Selection]: ExtractDialectRaw<Selection[K]>;
 }[keyof Selection] : never;
+/** Walks a selection tree and extracts the effective dialects referenced by its leaves. */
+export type ExtractDialect<Selection> = NormalizeDialect<Extract<ExtractDialectRaw<Selection>, string>>;
 /**
  * Minimal table-like shape required by `from(...)` and joins.
  *
@@ -419,8 +445,7 @@ export type MutationTargetNamesOf<Target extends MutationTargetInput> = Target e
 export type UpdateInputOfTarget<Target extends MutationTargetInput> = Target extends MutationTargetLike ? MutationInputOf<Table.UpdateOf<Target>> : Target extends MutationTargetTuple ? Simplify<{
     readonly [K in MutationTargetNamesOf<Target>]?: MutationInputOf<Table.UpdateOf<MutationTargetByName<Target, K>>>;
 }> : never;
-/** Extracts the effective dialect from a source. */
-export type SourceDialectOf<Source extends SourceLike> = Source extends TableLike<any, infer Dialect> ? Dialect : Source extends {
+type SourceDialectOfRaw<Source extends SourceLike> = Source extends TableLike<any, infer Dialect> ? Dialect : Source extends {
     readonly kind: "derived";
     readonly plan: infer PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>;
 } ? PlanDialectOf<PlanValue> : Source extends {
@@ -432,6 +457,8 @@ export type SourceDialectOf<Source extends SourceLike> = Source extends TableLik
 } ? PlanDialectOf<PlanValue> : Source extends {
     readonly dialect: infer Dialect extends string;
 } ? Dialect : never;
+/** Extracts the effective dialect from a source. */
+export type SourceDialectOf<Source extends SourceLike> = NormalizeDialect<SourceDialectOfRaw<Source>>;
 /** Extracts the base table name from a source. */
 export type SourceBaseNameOf<Source extends SourceLike> = Source extends TableLike<any, any> ? Source[typeof Table.TypeId]["baseName"] : Source extends {
     readonly kind: "derived";
@@ -493,7 +520,7 @@ export type RequiredOfPlan<PlanValue extends QueryPlan<any, any, any, any, any,
 /** Extracts the available-source scope carried by a query plan. */
 export type AvailableOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = QueryPlanParts<PlanValue>["available"];
 /** Extracts the effective dialect carried by a query plan. */
-export type PlanDialectOf<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = QueryPlanParts<PlanValue>["dialect"];
+export type PlanDialectOf<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = NormalizeDialect<QueryPlanParts<PlanValue>["dialect"]>;
 /** Extracts the grouped-source phantom carried by a query plan. */
 export type GroupedOfPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any, any, any>> = QueryPlanState<PlanValue>["grouped"];
 /** Extracts the available-name phantom carried by a query plan. */
@@ -562,7 +589,7 @@ type MergeNullability<Left extends Expression.Nullability, Right extends Express
 /** Folds nullability across a tuple for null-propagating scalar operators. */
 export type MergeNullabilityTuple<Values extends readonly Expression.Any[], Current extends Expression.Nullability = "never"> = Values extends readonly [infer Head extends Expression.Any, ...infer Tail extends readonly Expression.Any[]] ? MergeNullabilityTuple<Tail, MergeNullability<Current, Expression.NullabilityOf<Head>>> : Current;
 /** Dialect union across a tuple of expressions. */
-export type TupleDialect<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : DialectOf<Values[number]>;
+export type TupleDialect<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : NormalizeDialect<DialectOf<Values[number]>>;
 /** Dependency union across a tuple of scalar expressions. */
 export type TupleDependencies<Values extends readonly Expression.Any[]> = Values[number] extends never ? never : DependenciesOf<Values[number]>;
 /** Builds the canonical dependency union from a string union of table names. */
@@ -661,7 +688,7 @@ type AggregationCompatibilityError<PlanValue extends QueryPlan<any, any, any, an
 };
 type DialectCompatibilityError<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = PlanValue & {
     readonly __effect_qb_error__: "effect-qb: plan dialect is not compatible with the target renderer or executor";
-    readonly __effect_qb_plan_dialect__: PlanValue[typeof RowSet.TypeId]["dialect"];
+    readonly __effect_qb_plan_dialect__: PlanDialectOf<PlanValue>;
     readonly __effect_qb_target_dialect__: EngineDialect;
     readonly __effect_qb_hint__: "Use the matching dialect module or renderer/executor";
 };
@@ -678,11 +705,11 @@ export type AggregationCompatiblePlan<PlanValue extends QueryPlan<any, any, any,
 /** Narrows a query plan to aggregate-compatible, source-complete plans. */
 export type CompletePlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = StatementOfPlan<PlanValue> extends "insert" ? InsertSourceStateOfPlan<PlanValue> extends "missing" ? InsertHasOptionalDefaults<PlanValue> extends true ? PlanValue : InsertSourceCompletenessError<PlanValue> : HasKnownOutstanding<RequiredOfPlan<PlanValue>> extends true ? SourceCompletenessError<PlanValue, Extract<RequiredOfPlan<PlanValue>, string>> : IsAggregationCompatibleSelection<SelectionOfPlan<PlanValue>, GroupedOfPlan<PlanValue>> extends true ? PlanValue : AggregationCompatibilityError<PlanValue> : HasKnownOutstanding<RequiredOfPlan<PlanValue>> extends true ? SourceCompletenessError<PlanValue, Extract<RequiredOfPlan<PlanValue>, string>> : IsAggregationCompatibleSelection<SelectionOfPlan<PlanValue>, GroupedOfPlan<PlanValue>> extends true ? PlanValue : AggregationCompatibilityError<PlanValue>;
 /** Whether a plan dialect is compatible with a target engine dialect. */
-type IsDialectCompatible<PlanDialect extends string, EngineDialect extends string> = [PlanDialect] extends [never] ? true : Extract<PlanDialect, EngineDialect> extends never ? false : true;
+type IsDialectCompatible<PlanDialect extends string, EngineDialect extends string> = [PlanDialect] extends [never] ? true : Exclude<PlanDialect, EngineDialect | "standard"> extends never ? true : false;
 /** Narrows a complete plan to those compatible with a target engine dialect. */
-export type DialectCompatiblePlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true ? CompletePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
+export type DialectCompatiblePlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true ? CompletePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
 /** Nested-plan compatibility used by subquery expressions such as `exists(...)`. */
-export type DialectCompatibleNestedPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanValue[typeof RowSet.TypeId]["dialect"], EngineDialect> extends true ? AggregationCompatiblePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
+export type DialectCompatibleNestedPlan<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>, EngineDialect extends string> = IsDialectCompatible<PlanDialectOf<PlanValue>, EngineDialect> extends true ? AggregationCompatiblePlan<PlanValue> : DialectCompatibilityError<PlanValue, EngineDialect>;
 type SetOperandStatement = "select" | "set";
 type IsUnion<Value, All = Value> = Value extends any ? ([All] extends [Value] ? false : true) : never;
 type SingleSelectedExpressionError<PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>> = PlanValue & {