effect-qb 0.12.3 → 0.14.0

package/src/internal/{query-factory.ts → postgres-query.ts}

@@ -1,6 +1,8 @@
 import { pipeArguments } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 
+import { postgresDatatypes } from "../postgres/datatypes/index.js"
+
 import * as Expression from "./expression.js"
 import * as Plan from "./plan.js"
 import * as Table from "./table.js"
@@ -54,6 +56,7 @@ import {
   type OrderDirection,
   type OutstandingOfPlan,
   type PlanDialectOf,
+  type PresenceWitnessKeysOfSource,
   type PredicateInput,
   type QueryPlan,
   type OutputOfSelection,
@@ -76,6 +79,7 @@ import {
   type MutationTargetOfPlan,
   type MergeCapabilities,
   type MutationTargetInput,
+  type MutationValuesInput,
   type SourceOf,
   type SourceDialectOf,
   type SourceLike,
@@ -98,6 +102,7 @@ import {
   type ResultRow
 } from "./query.js"
 import * as ExpressionAst from "./expression-ast.js"
+import { presenceWitnessesOfSourceLike } from "./implication-runtime.js"
 import type { JsonNode } from "./json/ast.js"
 import type { JsonPathUsageError } from "./json/errors.js"
 import * as JsonPath from "./json/path.js"
@@ -116,7 +121,9 @@ import type {
   NormalizeJsonLiteral
 } from "./json/types.js"
 import type { AssumeTrue } from "./predicate-analysis.js"
+import type { FormulaOfPredicate } from "./predicate-normalize.js"
 import type { TrueFormula } from "./predicate-formula.js"
+import { assumeFormulaTrue, formulaOfExpression as formulaOfExpressionRuntime, trueFormula } from "./predicate-runtime.js"
 import { dedupeGroupedExpressions } from "./grouping-key.js"
 import { makeCteSource, makeDerivedSource, makeLateralSource } from "./derived-table.js"
 import * as ProjectionAlias from "./projection-alias.js"
@@ -246,6 +253,19 @@ type DialectDbTypeOfInput<
   NullDb extends Expression.DbType.Any
 > = Expression.DbTypeOf<DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
 
+type JoinPresenceFormula<
+  Kind extends QueryAst.JoinKind,
+  Predicate extends PredicateInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = Kind extends "inner" | "left"
+  ? FormulaOfPredicate<DialectAsExpression<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>>
+  : TrueFormula
+
 type ComparableInput<
   Left extends ExpressionInput,
   Right extends ExpressionInput,
@@ -757,7 +777,7 @@ type DialectStringExpressionTuple<
 }
 
 /** Names of sources already available to a plan. */
-type AvailableNames<Available extends Record<string, Plan.Source>> = Extract<keyof Available, string>
+type AvailableNames<Available extends Record<string, Plan.AnySource>> = Extract<keyof Available, string>
 
 type PlanAssumptionsAfterWhere<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
@@ -773,6 +793,37 @@ type PlanAssumptionsAfterWhere<
   DialectAsExpression<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
 >
 
+type PlanAssumptionsAfterHaving<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Predicate extends HavingPredicateInput,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = AssumeTrue<
+  AssumptionsOfPlan<PlanValue>,
+  DialectAsExpression<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+>
+
+type PlanAssumptionsAfterJoin<
+  PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+  Predicate extends PredicateInput,
+  Kind extends QueryAst.JoinKind,
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = Kind extends "inner"
+  ? AssumeTrue<
+      AssumptionsOfPlan<PlanValue>,
+      DialectAsExpression<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+    >
+  : AssumptionsOfPlan<PlanValue>
+
 type ScalarSubqueryInput<
   PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
   EngineDialect extends string
@@ -803,6 +854,53 @@ type AstBackedExpression<
   readonly [ExpressionAst.TypeId]: Ast
 }
 
+type AppendDialectExpressionTuple<
+  Current extends readonly Expression.Any[],
+  More extends readonly ExpressionInput[],
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = readonly [
+  ...Current,
+  ...DialectExpressionTuple<More, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+]
+
+type VariadicBooleanExpression<
+  Kind extends "and" | "or",
+  Values extends readonly Expression.Any[],
+  Dialect extends string,
+  TextDb extends Expression.DbType.Any,
+  NumericDb extends Expression.DbType.Any,
+  BoolDb extends Expression.DbType.Any,
+  TimestampDb extends Expression.DbType.Any,
+  NullDb extends Expression.DbType.Any
+> = AstBackedExpression<
+  boolean,
+  BoolDb,
+  MergeNullabilityTuple<Values>,
+  TupleDialect<Values>,
+  MergeAggregationTuple<Values>,
+  TupleSource<Values>,
+  TupleDependencies<Values>,
+  ExpressionAst.VariadicNode<Kind, Values>
+> & {
+  pipe<More extends readonly [ExpressionInput, ...ExpressionInput[]]>(
+    ...values: More
+  ): VariadicBooleanExpression<
+    Kind,
+    AppendDialectExpressionTuple<Values, More, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+    Dialect,
+    TextDb,
+    NumericDb,
+    BoolDb,
+    TimestampDb,
+    NullDb
+  >
+}
+
 type JsonRuntime<Value> = NormalizeJsonLiteral<Value> extends never
   ? unknown
   : NormalizeJsonLiteral<Value>
@@ -845,6 +943,29 @@ type JsonExpressionLike<Runtime = unknown> = Expression.Expression<
   Expression.SourceNullabilityMode
 >
 
+type JsonDbOfExpression<Value extends JsonExpressionLike<any>> = Expression.DbTypeOf<Value>
+
+type JsonKindOfInput<
+  Value,
+  Fallback extends string = "json"
+> = Value extends Expression.Any
+  ? Expression.DbTypeOf<Value> extends Expression.DbType.Json<any, infer Kind> ? Kind : Fallback
+  : Fallback
+
+type JsonConcatKind<
+  Left,
+  Right,
+  EngineDialect extends string
+> = EngineDialect extends "postgres"
+  ? "jsonb"
+  : JsonKindOfInput<Left> extends "jsonb"
+    ? "jsonb"
+    : JsonKindOfInput<Right> extends "jsonb"
+      ? "jsonb"
+      : "json"
+
+type JsonbKindForDialect<EngineDialect extends string> = EngineDialect extends "postgres" ? "jsonb" : "json"
+
 type JsonValueInput = JsonLiteralInput | Expression.Any
 
 type JsonPathInput = JsonPath.Path<any> | JsonPath.CanonicalSegment
@@ -1268,17 +1389,24 @@ type NumberWindowExpression<
  * that manufacture new expressions are specialized to the supplied dialect DB
  * types instead of relying on the Postgres-default root module.
  */
-export function makeDialectQuery<
-  Dialect extends string,
-  TextDb extends Expression.DbType.Any,
-  NumericDb extends Expression.DbType.Any,
-  BoolDb extends Expression.DbType.Any,
-  TimestampDb extends Expression.DbType.Any,
-  NullDb extends Expression.DbType.Any,
-  TypeWitnesses extends object = object
->(
-  profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, TypeWitnesses>
-) {
+export const postgresQuery = (() => {
+type Dialect = "postgres"
+type TextDb = Expression.DbType.PgText
+type NumericDb = Expression.DbType.PgFloat8
+type BoolDb = Expression.DbType.PgBool
+type TimestampDb = Expression.DbType.PgTimestamp
+type NullDb = Expression.DbType.Base<"postgres", "null">
+type TypeWitnesses = typeof postgresDatatypes
+
+const profile: QueryDialectProfile<Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, TypeWitnesses> = {
+  dialect: "postgres",
+  textDb: { dialect: "postgres", kind: "text" } as TextDb,
+  numericDb: { dialect: "postgres", kind: "float8" } as NumericDb,
+  boolDb: { dialect: "postgres", kind: "bool" } as BoolDb,
+  timestampDb: { dialect: "postgres", kind: "timestamp" } as TimestampDb,
+  nullDb: { dialect: "postgres", kind: "null" } as NullDb,
+  type: postgresDatatypes
+}
   const ValuesInputProto = {
     pipe(this: unknown) {
       return pipeArguments(this, arguments)
@@ -1318,6 +1446,51 @@ export function makeDialectQuery<
       value
     })
 
+  const column = <
+    Name extends string,
+    Db extends Expression.DbType.Any
+  >(
+    name: Name,
+    dbType: Db,
+    nullable = false
+  ): Expression.Expression<
+    Expression.RuntimeOfDbType<Db> | null,
+    Db,
+    Expression.Nullability,
+    Dialect,
+    "scalar",
+    never,
+    {},
+    "resolved"
+  > & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<"", Name>
+  } =>
+    makeExpression({
+      runtime: undefined as unknown as Expression.RuntimeOfDbType<Db> | (typeof nullable extends true ? null : never),
+      dbType,
+      nullability: (nullable ? "maybe" : "never") as typeof nullable extends true ? "maybe" : "never",
+      dialect: profile.dialect as Dialect,
+      aggregation: "scalar",
+      source: undefined as never,
+      sourceNullability: "resolved" as const,
+      dependencies: {}
+    }, {
+      kind: "column",
+      tableName: "",
+      columnName: name
+    }) as Expression.Expression<
+      Expression.RuntimeOfDbType<Db> | null,
+      Db,
+      Expression.Nullability,
+      Dialect,
+      "scalar",
+      never,
+      {},
+      "resolved"
+    > & {
+      readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<"", Name>
+    }
+
   const toDialectExpression = <Value extends ExpressionInput>(
     value: Value
   ): DialectAsExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> => {
@@ -1349,6 +1522,69 @@ export function makeDialectQuery<
       ? literal(value)
       : value) as DialectAsNumericExpression<Value, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
 
+  const flattenVariadicBooleanExpressions = <
+    Kind extends "and" | "or",
+    Values extends readonly Expression.Any[]
+  >(
+    kind: Kind,
+    values: Values
+  ): readonly Expression.Any[] => {
+    const flattened: Array<Expression.Any> = []
+    for (const value of values) {
+      const ast = (value as unknown as { readonly [ExpressionAst.TypeId]: ExpressionAst.Any })[ExpressionAst.TypeId]
+      if (ast.kind === kind) {
+        flattened.push(...ast.values)
+      } else {
+        flattened.push(value)
+      }
+    }
+    return flattened
+  }
+
+  const makeVariadicBooleanExpression = <
+    Kind extends "and" | "or",
+    Values extends readonly Expression.Any[]
+  >(
+    kind: Kind,
+    values: Values
+  ): VariadicBooleanExpression<Kind, Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> => {
+    const expressions = flattenVariadicBooleanExpressions(kind, values) as Values
+    const expression = makeExpression({
+      runtime: true as boolean,
+      dbType: profile.boolDb as BoolDb,
+      nullability: mergeNullabilityManyRuntime(expressions) as MergeNullabilityTuple<Values>,
+      dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as TupleDialect<Values>,
+      aggregation: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<Values>,
+      source: mergeManySources(expressions) as TupleSource<Values>,
+      sourceNullability: "propagate" as const,
+      dependencies: mergeManyDependencies(expressions) as TupleDependencies<Values>
+    }, {
+      kind,
+      values: expressions
+    }) as VariadicBooleanExpression<Kind, Values, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>
+
+    Object.defineProperty(expression, "pipe", {
+      configurable: true,
+      writable: true,
+      value(this: Expression.Any) {
+        if (arguments.length === 0) {
+          return this
+        }
+        const operations = Array.from(arguments)
+        if (operations.every((operation) => typeof operation !== "function")) {
+          const appended = operations.map((operation) => toDialectExpression(operation as ExpressionInput)) as readonly Expression.Any[]
+          return makeVariadicBooleanExpression(kind, [...expressions, ...appended] as const)
+        }
+        if (operations.every((operation) => typeof operation === "function")) {
+          return pipeArguments(this, arguments)
+        }
+        throw new TypeError(`Cannot mix query expressions and pipe functions inside ${kind}(...).pipe(...)`)
+      }
+    })
+
+    return expression
+  }
+
   const extractRequiredFromDialectInputRuntime = (value: ExpressionInput): readonly string[] => {
     const expression = toDialectExpression(value)
     return Object.keys(expression[Expression.TypeId].dependencies)
@@ -1584,6 +1820,46 @@ export function makeDialectQuery<
     return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "ilike")
   }
 
+  const regexMatch = <
+    Left extends StringExpressionInput,
+    Right extends StringExpressionInput
+  >(
+    ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexMatch">
+  ): BinaryPredicateExpression<Left, Right, "regexMatch"> => {
+    const [left, right] = args as [Left, Right]
+    return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexMatch")
+  }
+
+  const regexIMatch = <
+    Left extends StringExpressionInput,
+    Right extends StringExpressionInput
+  >(
+    ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexIMatch">
+  ): BinaryPredicateExpression<Left, Right, "regexIMatch"> => {
+    const [left, right] = args as [Left, Right]
+    return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexIMatch")
+  }
+
+  const regexNotMatch = <
+    Left extends StringExpressionInput,
+    Right extends StringExpressionInput
+  >(
+    ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexNotMatch">
+  ): BinaryPredicateExpression<Left, Right, "regexNotMatch"> => {
+    const [left, right] = args as [Left, Right]
+    return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexNotMatch")
+  }
+
+  const regexNotIMatch = <
+    Left extends StringExpressionInput,
+    Right extends StringExpressionInput
+  >(
+    ...args: TextArgs<Left, Right, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb, "regexNotIMatch">
+  ): BinaryPredicateExpression<Left, Right, "regexNotIMatch"> => {
+    const [left, right] = args as [Left, Right]
+    return buildBinaryPredicate(left as ExpressionInput, right as ExpressionInput, "regexNotIMatch")
+  }
+
   const isDistinctFrom = <
     Left extends ExpressionInput,
     Right extends ExpressionInput
@@ -1812,6 +2088,13 @@ export function makeDialectQuery<
     variant: "set"
   })
 
+  const custom = <Kind extends string>(
+    kind: Kind
+  ): Expression.DbType.Base<Dialect, Kind> => ({
+    dialect: profile.dialect,
+    kind
+  })
+
   const type = {
     ...profile.type,
     array,
@@ -1820,7 +2103,8 @@ export function makeDialectQuery<
     record,
     domain,
     enum: enum_,
-    set
+    set,
+    custom
   }
 
   const makeJsonDb = <Kind extends string>(
@@ -1828,11 +2112,11 @@ export function makeDialectQuery<
   ): JsonDb<Dialect, Kind> => ({
     dialect: profile.dialect,
     kind,
-    variant: "json"
+    variant: (kind === "jsonb" ? "jsonb" : "json") as Kind extends "jsonb" ? "jsonb" : "json"
   })
 
   const jsonDb = makeJsonDb("json")
-  const jsonbDb = makeJsonDb((profile.dialect === "postgres" ? "jsonb" : "json") as string)
+  const jsonbDb = makeJsonDb("jsonb" as JsonbKindForDialect<Dialect>)
 
   const isExpressionValue = (value: unknown): value is Expression.Any =>
     value !== null && typeof value === "object" && Expression.TypeId in value
@@ -1901,6 +2185,14 @@ export function makeDialectQuery<
     SourceNullability
   >
 
+  const jsonDbTypeOf = <Base extends JsonExpressionLike<any>>(
+    base: Base
+  ): JsonDbOfExpression<Base> => base[Expression.TypeId].dbType as JsonDbOfExpression<Base>
+
+  const resolveJsonMergeDbType = (
+    ..._values: readonly Expression.Any[]
+  ): Expression.DbType.Json<any, any> => jsonbDb
+
   const makeJsonLiteralExpression = <Value extends JsonLiteralInput>(
     value: Value,
     dbType: Expression.DbType.Json<any, any> = jsonDb
@@ -1961,7 +2253,7 @@ export function makeDialectQuery<
     target: Target & JsonPathGuard<Expression.RuntimeOf<Base>, Target, "json.get">
   ): JsonExpression<
     JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.get">,
-    JsonDb<Dialect>,
+    JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.get">>,
     DialectOf<Base>,
     AggregationOf<Base>,
@@ -1977,7 +2269,7 @@ export function makeDialectQuery<
       [base],
       {
         runtime: undefined as unknown as JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.get">,
-        dbType: jsonDb,
+        dbType: jsonDbTypeOf(base),
         nullability: undefined as unknown as JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.get">>
       },
       {
@@ -1987,7 +2279,7 @@ export function makeDialectQuery<
       }
     ) as JsonExpression<
       JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.get">,
-      JsonDb<Dialect>,
+      JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.get">>,
       DialectOf<Base>,
       AggregationOf<Base>,
@@ -2056,7 +2348,7 @@ export function makeDialectQuery<
       [base],
       {
         runtime: undefined as unknown as JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.access">,
-        dbType: jsonDb,
+        dbType: jsonDbTypeOf(base),
         nullability: undefined as unknown as JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.access">>
       },
       {
@@ -2079,7 +2371,7 @@ export function makeDialectQuery<
       [base],
       {
         runtime: undefined as unknown as JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.traverse">,
-        dbType: jsonDb,
+        dbType: jsonDbTypeOf(base),
         nullability: undefined as unknown as JsonNullabilityOf<JsonPathOutputOf<Expression.RuntimeOf<Base>, Target, "json.traverse">>
       },
       {
@@ -2225,7 +2517,7 @@ export function makeDialectQuery<
     target: Target & JsonDeleteGuard<Expression.RuntimeOf<Base>, Target, "json.delete">
   ): JsonExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">,
-    JsonDb<Dialect>,
+    JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">>,
     DialectOf<Base>,
     AggregationOf<Base>,
@@ -2238,7 +2530,7 @@ export function makeDialectQuery<
       [base],
       {
         runtime: undefined as unknown as JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">,
-        dbType: jsonDb,
+        dbType: jsonDbTypeOf(base),
         nullability: undefined as unknown as JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">>
       },
       {
@@ -2248,7 +2540,7 @@ export function makeDialectQuery<
       }
     ) as JsonExpression<
       JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">,
-      JsonDb<Dialect>,
+      JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.delete">>,
       DialectOf<Base>,
       AggregationOf<Base>,
@@ -2266,7 +2558,7 @@ export function makeDialectQuery<
     target: Target & JsonDeleteGuard<Expression.RuntimeOf<Base>, Target, "json.remove">
   ): JsonExpression<
     JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">,
-    JsonDb<Dialect>,
+    JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">>,
     DialectOf<Base>,
     AggregationOf<Base>,
@@ -2279,7 +2571,7 @@ export function makeDialectQuery<
       [base],
       {
         runtime: undefined as unknown as JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">,
-        dbType: jsonDb,
+        dbType: jsonDbTypeOf(base),
         nullability: undefined as unknown as JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">>
       },
       {
@@ -2289,7 +2581,7 @@ export function makeDialectQuery<
       }
     ) as JsonExpression<
       JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">,
-      JsonDb<Dialect>,
+      JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonDeleteOutputOf<Expression.RuntimeOf<Base>, Target, "json.remove">>,
       DialectOf<Base>,
       AggregationOf<Base>,
@@ -2312,7 +2604,7 @@ export function makeDialectQuery<
     } = {}
   ): JsonExpression<
     JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
-    JsonDb<Dialect>,
+    JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">>,
     DialectOf<Base>,
     AggregationOf<Base>,
@@ -2326,7 +2618,7 @@ export function makeDialectQuery<
       [base, newValue],
       {
         runtime: undefined as unknown as JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
-        dbType: jsonDb,
+        dbType: jsonDbTypeOf(base),
         nullability: undefined as unknown as JsonNullabilityOf<JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">>
       },
       {
@@ -2338,7 +2630,7 @@ export function makeDialectQuery<
       }
     ) as JsonExpression<
       JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">,
-      JsonDb<Dialect>,
+      JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonSetOutputOf<Expression.RuntimeOf<Base>, Target, Next, "json.set">>,
       DialectOf<Base>,
       AggregationOf<Base>,
@@ -2362,7 +2654,7 @@ export function makeDialectQuery<
     } = {}
   ): JsonExpression<
     JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">,
-    JsonDb<Dialect>,
+    JsonDbOfExpression<Base>,
     JsonNullabilityOf<JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">>,
     DialectOf<Base>,
     AggregationOf<Base>,
@@ -2377,7 +2669,7 @@ export function makeDialectQuery<
       [base, insert],
       {
         runtime: undefined as unknown as JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">,
-        dbType: jsonDb,
+        dbType: jsonDbTypeOf(base),
         nullability: undefined as unknown as JsonNullabilityOf<JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">>
       },
       {
@@ -2389,7 +2681,7 @@ export function makeDialectQuery<
       }
     ) as JsonExpression<
       JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">,
-      JsonDb<Dialect>,
+      JsonDbOfExpression<Base>,
       JsonNullabilityOf<JsonInsertOutputOf<Expression.RuntimeOf<Base>, Target, Next, InsertAfter, "json.insert">>,
       DialectOf<Base>,
       AggregationOf<Base>,
@@ -2399,7 +2691,11 @@ export function makeDialectQuery<
     >
   }
 
-  const jsonConcat = <
+  const jsonConcatAs = <
+    Db extends Expression.DbType.Json<any, any>
+  >(
+    dbType: Db
+  ) => <
     Left extends JsonValueInput,
     Right extends JsonValueInput
   >(
@@ -2407,7 +2703,7 @@ export function makeDialectQuery<
     right: Right
   ): JsonExpression<
     JsonConcatResult<JsonOutputOfInput<Left>, JsonOutputOfInput<Right>>,
-    JsonDb<Dialect>,
+    Db,
     "maybe",
     Dialect,
     Expression.AggregationKind,
@@ -2421,7 +2717,7 @@ export function makeDialectQuery<
       [leftExpression, rightExpression],
       {
         runtime: undefined as unknown as JsonConcatResult<JsonOutputOfInput<Left>, JsonOutputOfInput<Right>>,
-        dbType: jsonDb,
+        dbType,
         nullability: "maybe" as const
       },
       {
@@ -2431,7 +2727,7 @@ export function makeDialectQuery<
       }
     ) as JsonExpression<
       JsonConcatResult<JsonOutputOfInput<Left>, JsonOutputOfInput<Right>>,
-      JsonDb<Dialect>,
+      Db,
       "maybe",
       Dialect,
       Expression.AggregationKind,
@@ -2441,7 +2737,11 @@ export function makeDialectQuery<
     >
   }
 
-  const jsonMerge = <
+  const jsonMergeAs = <
+    Db extends Expression.DbType.Json<any, any>
+  >(
+    dbType: Db
+  ) => <
     Left extends JsonValueInput,
     Right extends JsonValueInput
   >(
@@ -2454,7 +2754,7 @@ export function makeDialectQuery<
       [leftExpression, rightExpression],
       {
         runtime: undefined as unknown as JsonConcatResult<JsonOutputOfInput<Left>, JsonOutputOfInput<Right>>,
-        dbType: jsonDb,
+        dbType,
         nullability: "maybe" as const
       },
       {
@@ -2465,6 +2765,9 @@ export function makeDialectQuery<
     )
   }
 
+  const jsonConcat = jsonConcatAs(resolveJsonMergeDbType())
+  const jsonMerge = jsonMergeAs(resolveJsonMergeDbType())
+
   const jsonKeyExists = <
     Base extends JsonExpressionLike<any>,
     Key extends string
@@ -2486,7 +2789,11 @@ export function makeDialectQuery<
     }
   )
 
-  const jsonBuildObject = <
+  const jsonBuildObjectAs = <
+    Db extends Expression.DbType.Json<any, any>
+  >(
+    dbType: Db
+  ) => <
     Shape extends Record<string, JsonValueInput>
   >(
     shape: Shape
@@ -2499,7 +2806,7 @@ export function makeDialectQuery<
       entries.map((entry) => entry.value),
       {
         runtime: {} as JsonObjectOutput<Shape>,
-        dbType: jsonDb,
+        dbType,
         nullability: "never" as const,
         sourceNullability: "resolved" as const
       },
@@ -2510,7 +2817,11 @@ export function makeDialectQuery<
     )
   }
 
-  const jsonBuildArray = <
+  const jsonBuildArrayAs = <
+    Db extends Expression.DbType.Json<any, any>
+  >(
+    dbType: Db
+  ) => <
     Values extends readonly JsonValueInput[]
   >(
     ...values: Values
@@ -2520,7 +2831,7 @@ export function makeDialectQuery<
       expressions,
       {
         runtime: [] as JsonArrayOutput<Values>,
-        dbType: jsonDb,
+        dbType,
         nullability: "never" as const,
         sourceNullability: "resolved" as const
       },
@@ -2531,6 +2842,11 @@ export function makeDialectQuery<
     )
   }
 
+  const jsonBuildObject = jsonBuildObjectAs(jsonDb)
+  const jsonBuildArray = jsonBuildArrayAs(jsonDb)
+  const jsonbBuildObject = jsonBuildObjectAs(jsonbDb)
+  const jsonbBuildArray = jsonBuildArrayAs(jsonbDb)
+
   const jsonToJson = <Value extends JsonValueInput>(
     value: Value
   ) => toJsonValueExpression(value, "jsonToJson", jsonDb) as JsonExpression<
@@ -2548,7 +2864,7 @@ export function makeDialectQuery<
     value: Value
   ) => toJsonValueExpression(value, "jsonToJsonb", jsonbDb) as JsonExpression<
     JsonOutputOfInput<Value>,
-    JsonDb<Dialect, string>,
+    JsonDb<Dialect, JsonbKindForDialect<Dialect>>,
     JsonNullabilityOf<JsonOutputOfInput<Value>>,
     string,
     Expression.AggregationKind,
@@ -2645,7 +2961,7 @@ export function makeDialectQuery<
     [base],
     {
       runtime: undefined as unknown as JsonStripNullsResult<Expression.RuntimeOf<Base>>,
-      dbType: jsonDb,
+      dbType: jsonDbTypeOf(base),
       nullability: undefined as unknown as JsonNullabilityOf<JsonStripNullsResult<Expression.RuntimeOf<Base>>>
     },
     {
@@ -2728,83 +3044,79 @@ export function makeDialectQuery<
     pathMatch: jsonPathMatch
   }
 
+  const jsonb = {
+    key: JsonPath.key,
+    index: JsonPath.index,
+    wildcard: JsonPath.wildcard,
+    slice: JsonPath.slice,
+    descend: JsonPath.descend,
+    path: JsonPath.path,
+    get: jsonGet,
+    access: jsonAccess,
+    traverse: jsonTraverse,
+    text: jsonText,
+    accessText: jsonAccessText,
+    traverseText: jsonTraverseText,
+    contains: jsonContains,
+    containedBy: jsonContainedBy,
+    hasKey: jsonHasKey,
+    keyExists: jsonKeyExists,
+    hasAnyKeys: jsonHasAnyKeys,
+    hasAllKeys: jsonHasAllKeys,
+    delete: jsonDelete,
+    remove: jsonRemove,
+    set: jsonSet,
+    insert: jsonInsert,
+    concat: jsonConcatAs(jsonbDb),
+    merge: jsonMergeAs(jsonbDb),
+    buildObject: jsonbBuildObject,
+    buildArray: jsonbBuildArray,
+    toJsonb: jsonToJsonb,
+    typeOf: jsonTypeOf,
+    length: jsonLength,
+    keys: jsonKeys,
+    stripNulls: jsonStripNulls,
+    pathExists: jsonPathExists,
+    pathMatch: jsonPathMatch
+  }
+
   const and = <
     Values extends readonly [ExpressionInput, ...ExpressionInput[]]
   >(
     ...values: Values
-  ): AstBackedExpression<
-    boolean,
+  ): VariadicBooleanExpression<
+    "and",
+    { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[],
+    Dialect,
+    TextDb,
+    NumericDb,
     BoolDb,
-    MergeNullabilityTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    TupleDialect<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    MergeAggregationTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    TupleSource<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    TupleDependencies<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    ExpressionAst.VariadicNode<"and", { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>
-  > => {
-    const expressions = values.map((value) => toDialectExpression(value)) as readonly Expression.Any[]
-    return makeExpression({
-      runtime: true as boolean,
-      dbType: profile.boolDb as BoolDb,
-      nullability: mergeNullabilityManyRuntime(expressions) as MergeNullabilityTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as TupleDialect<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      aggregation: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      source: mergeManySources(expressions) as TupleSource<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      sourceNullability: "propagate" as const,
-      dependencies: mergeManyDependencies(expressions) as TupleDependencies<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>
-    }, {
-      kind: "and",
-      values: expressions
-    }) as AstBackedExpression<
-      boolean,
-      BoolDb,
-      MergeNullabilityTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      TupleDialect<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      MergeAggregationTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      TupleSource<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      TupleDependencies<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      ExpressionAst.VariadicNode<"and", { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>
-    >
-  }
+    TimestampDb,
+    NullDb
+  > =>
+    makeVariadicBooleanExpression(
+      "and",
+      values.map((value) => toDialectExpression(value)) as { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]
+    )
 
   const or = <
     Values extends readonly [ExpressionInput, ...ExpressionInput[]]
   >(
     ...values: Values
-  ): AstBackedExpression<
-    boolean,
+  ): VariadicBooleanExpression<
+    "or",
+    { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[],
+    Dialect,
+    TextDb,
+    NumericDb,
     BoolDb,
-    MergeNullabilityTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    TupleDialect<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    MergeAggregationTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    TupleSource<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    TupleDependencies<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-    ExpressionAst.VariadicNode<"or", { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>
-  > => {
-    const expressions = values.map((value) => toDialectExpression(value)) as readonly Expression.Any[]
-    return makeExpression({
-      runtime: true as boolean,
-      dbType: profile.boolDb as BoolDb,
-      nullability: mergeNullabilityManyRuntime(expressions) as MergeNullabilityTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as TupleDialect<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      aggregation: mergeAggregationManyRuntime(expressions) as MergeAggregationTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      source: mergeManySources(expressions) as TupleSource<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      sourceNullability: "propagate" as const,
-      dependencies: mergeManyDependencies(expressions) as TupleDependencies<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>
-    }, {
-      kind: "or",
-      values: expressions
-    }) as AstBackedExpression<
-      boolean,
-      BoolDb,
-      MergeNullabilityTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      TupleDialect<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      MergeAggregationTuple<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      TupleSource<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      TupleDependencies<{ readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>,
-      ExpressionAst.VariadicNode<"or", { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]>
-    >
-  }
+    TimestampDb,
+    NullDb
+  > =>
+    makeVariadicBooleanExpression(
+      "or",
+      values.map((value) => toDialectExpression(value)) as { readonly [K in keyof Values]: DialectAsExpression<Values[K], Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb> } & readonly Expression.Any[]
+    )
 
   const not = <Value extends ExpressionInput>(
     value: Value
@@ -3370,6 +3682,84 @@ export function makeDialectQuery<
     >
   }
 
+  const call = <
+    Name extends string,
+    Args extends readonly ExpressionInput[]
+  >(
+    name: Name,
+    ...args: Args
+  ): Expression.Any => {
+    const expressions = args.map((value) => toDialectExpression(value)) as readonly Expression.Any[]
+    return makeExpression({
+      runtime: undefined as never,
+      dbType: profile.textDb,
+      nullability: "maybe",
+      dialect: (expressions.find((value) => value[Expression.TypeId].dialect !== undefined)?.[Expression.TypeId].dialect ?? profile.dialect) as Dialect,
+      aggregation: mergeAggregationManyRuntime(expressions),
+      source: mergeManySources(expressions),
+      sourceNullability: "resolved" as const,
+      dependencies: mergeManyDependencies(expressions)
+    }, {
+      kind: "function",
+      name,
+      args: expressions
+    }) as Expression.Any
+  }
+
+  const uuidGenerateV4 = (): Expression.Expression<
+    string,
+    Expression.DbType.PgUuid,
+    "never",
+    Dialect,
+    "scalar",
+    never,
+    {},
+    "resolved"
+  > & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<"uuid_generate_v4", readonly []>
+  } => makeExpression({
+    runtime: undefined as unknown as string,
+    dbType: { dialect: "postgres", kind: "uuid" } as Expression.DbType.PgUuid,
+    nullability: "never",
+    dialect: profile.dialect as Dialect,
+    aggregation: "scalar",
+    source: undefined as never,
+    sourceNullability: "resolved" as const,
+    dependencies: {}
+  }, {
+    kind: "function",
+    name: "uuid_generate_v4",
+    args: []
+  })
+
+  const nextVal = <Value extends ExpressionInput>(
+    value: Value
+  ): Expression.Expression<
+    Expression.RuntimeOfDbType<Expression.DbType.PgInt8>,
+    Expression.DbType.PgInt8,
+    "never",
+    Dialect,
+    "scalar",
+    never,
+    {},
+    "resolved"
+  > & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<"nextval", readonly [Expression.Any]>
+  } => makeExpression({
+    runtime: undefined as unknown as Expression.RuntimeOfDbType<Expression.DbType.PgInt8>,
+    dbType: { dialect: "postgres", kind: "int8" } as Expression.DbType.PgInt8,
+    nullability: "never",
+    dialect: profile.dialect as Dialect,
+    aggregation: "scalar",
+    source: undefined as never,
+    sourceNullability: "resolved" as const,
+    dependencies: {}
+  }, {
+    kind: "function",
+    name: "nextval",
+    args: [toDialectExpression(value as any)]
+  })
+
   type RuntimeCaseBranch = {
     readonly when: Expression.Any
     readonly then: Expression.Any
@@ -3802,7 +4192,7 @@ export function makeDialectQuery<
     const firstRow = rows[0]
     const firstColumns = Object.keys(firstRow)
     if (firstColumns.length === 0) {
-      throw new Error("values(...) rows must specify at least one column; use defaultValues(...) instead")
+      throw new Error("values(...) rows must specify at least one column; use insert(target) for default-only inserts instead")
     }
     const columns = firstColumns as [string, ...string[]]
     const normalizedRows = rows.map((row) => {
@@ -3916,10 +4306,12 @@ type DdlColumnInput = string | readonly string[]
 type NormalizeDdlColumns<Columns extends DdlColumnInput> =
   Columns extends readonly [infer Head extends string, ...infer Tail extends string[]]
     ? readonly [Head, ...Tail]
+    : Columns extends [infer Head extends string, ...infer Tail extends string[]]
+      ? readonly [Head, ...Tail]
     : Columns extends readonly string[]
-      ? Columns extends readonly [string, ...string[]]
-        ? Columns
-        : never
+      ? Columns[number] extends never
+        ? never
+        : readonly [Columns[number], ...Columns[number][]]
       : Columns extends string
         ? readonly [Columns]
         : never
@@ -4072,12 +4464,6 @@ type InsertPlanSelectionShapeError<
   readonly __effect_qb_hint__: "Project a flat object like select({ id: ..., email: ... }) with column-name keys"
 }
 
-type DefaultValuesError<Target extends MutationTargetLike> = Target & {
-  readonly __effect_qb_error__: "effect-qb: defaultValues(...) requires every insert column to be optional or generated"
-  readonly __effect_qb_required_columns__: RequiredKeys<Table.InsertOf<Target>>
-  readonly __effect_qb_hint__: "Use insert(...) for required columns, or mark columns nullable/hasDefault/generated"
-}
-
 type MysqlConflictTargetError<Target> = Target & {
   readonly __effect_qb_error__: "effect-qb: mysql does not support named or predicate-scoped conflict targets"
   readonly __effect_qb_hint__: "Use a column tuple target, or rely on MySQL duplicate-key resolution without target predicates"
@@ -4304,7 +4690,7 @@ type AstOf<Value extends Expression.Any> =
     ? Ast
     : never
 
-type AvailableNames<Available extends Record<string, Plan.Source>> = Extract<keyof Available, string>
+type AvailableNames<Available extends Record<string, Plan.AnySource>> = Extract<keyof Available, string>
 
 type RequiredFromInput<Value extends ExpressionInput> =
   Value extends Expression.Any
@@ -4362,7 +4748,7 @@ type SelectFromResult<
 > = QueryPlan<
   SelectionOfPlan<PlanValue>,
   Exclude<RequiredOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
-  AddAvailable<{}, SourceNameOf<CurrentSource>>,
+  AddAvailable<{}, SourceNameOf<CurrentSource>, "required", TrueFormula, PresenceWitnessKeysOfSource<CurrentSource>>,
   PlanDialectOf<PlanValue> | SourceDialectOf<CurrentSource>,
   GroupedOfPlan<PlanValue>,
   SourceNameOf<CurrentSource>,
@@ -4378,7 +4764,13 @@ type UpdateFromResult<
 > = QueryPlan<
   SelectionOfPlan<PlanValue>,
   Exclude<RequiredOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
-  AddAvailable<AvailableOfPlan<PlanValue>, SourceNameOf<CurrentSource>>,
+  AddAvailable<
+    AvailableOfPlan<PlanValue>,
+    SourceNameOf<CurrentSource>,
+    "required",
+    TrueFormula,
+    PresenceWitnessKeysOfSource<CurrentSource>
+  >,
   PlanDialectOf<PlanValue> | SourceDialectOf<CurrentSource>,
   GroupedOfPlan<PlanValue>,
   ScopedNamesOfPlan<PlanValue> | SourceNameOf<CurrentSource>,
@@ -4453,7 +4845,7 @@ type FromPlanResult<
 
 type MergeRequiredFromPredicate<
   Predicate extends PredicateInput | undefined,
-  Available extends Record<string, Plan.Source>
+  Available extends Record<string, Plan.AnySource>
 > = Predicate extends PredicateInput ? AddExpressionRequired<never, Available, Predicate> : never
 
 type AsCurriedInput<Dialect extends string> =
@@ -4558,34 +4950,77 @@ type AsCurriedResult<
     return makeDerivedSource(value as CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>, resolvedAlias)
   }
 
+  function with_<
+    Alias extends string
+  >(
+    alias: Alias
+  ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    value: CompletePlan<PlanValue>
+  ) => import("./query.js").CteSource<PlanValue, Alias>
   function with_<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
     value: CompletePlan<PlanValue>,
     alias: Alias
-  ): import("./query.js").CteSource<PlanValue, Alias> {
-    return makeCteSource(value, alias)
+  ): import("./query.js").CteSource<PlanValue, Alias>
+  function with_(valueOrAlias: unknown, alias?: string): unknown {
+    if (alias === undefined) {
+      return (value: unknown) => with_(value as any, valueOrAlias as string)
+    }
+    return makeCteSource(
+      valueOrAlias as CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>,
+      alias
+    )
   }
 
+  function withRecursive_<
+    Alias extends string
+  >(
+    alias: Alias
+  ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    value: CompletePlan<PlanValue>
+  ) => import("./query.js").CteSource<PlanValue, Alias>
   function withRecursive_<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
     value: CompletePlan<PlanValue>,
     alias: Alias
-  ): import("./query.js").CteSource<PlanValue, Alias> {
-    return makeCteSource(value, alias, true)
+  ): import("./query.js").CteSource<PlanValue, Alias>
+  function withRecursive_(valueOrAlias: unknown, alias?: string): unknown {
+    if (alias === undefined) {
+      return (value: unknown) => withRecursive_(value as any, valueOrAlias as string)
+    }
+    return makeCteSource(
+      valueOrAlias as CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>,
+      alias,
+      true
+    )
   }
 
+  function lateral<
+    Alias extends string
+  >(
+    alias: Alias
+  ): <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    value: PlanValue
+  ) => import("./query.js").LateralSource<PlanValue, Alias>
   function lateral<
     PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>,
     Alias extends string
   >(
     value: PlanValue,
     alias: Alias
-  ): import("./query.js").LateralSource<PlanValue, Alias> {
-    return makeLateralSource(value, alias)
+  ): import("./query.js").LateralSource<PlanValue, Alias>
+  function lateral(valueOrAlias: unknown, alias?: string): unknown {
+    if (alias === undefined) {
+      return (value: unknown) => lateral(value as any, valueOrAlias as string)
+    }
+    return makeLateralSource(
+      valueOrAlias as QueryPlan<any, any, any, any, any, any, any, any, any, any>,
+      alias
+    )
   }
 
   const values = <
@@ -5038,7 +5473,10 @@ type AsCurriedResult<
           predicate: predicateExpression
         }]
       },
-      undefined as unknown as PlanAssumptionsAfterWhere<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      assumeFormulaTrue(
+        currentQuery.assumptions,
+        formulaOfExpressionRuntime(predicateExpression)
+      ) as PlanAssumptionsAfterWhere<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       currentQuery.capabilities,
       currentQuery.statement as StatementOfPlan<PlanValue>)
     }
@@ -5071,6 +5509,7 @@ type AsCurriedResult<
 
       const sourceLike = source as SourceLike
       const { sourceName, sourceBaseName } = sourceDetails(sourceLike)
+      const presenceWitnesses = presenceWitnessesOfSourceLike(sourceLike)
 
       if (currentQuery.statement === "select") {
         const nextAst = {
@@ -5090,9 +5529,11 @@ type AsCurriedResult<
             [sourceName]: {
               name: sourceName,
               mode: "required",
-              baseName: sourceBaseName
+              baseName: sourceBaseName,
+              _presentFormula: trueFormula(),
+              _presenceWitnesses: presenceWitnesses
             }
-          } as AddAvailable<{}, string>,
+          } as AddAvailable<{}, string, "required", TrueFormula, PresenceWitnessKeysOfSource<Extract<CurrentSource, SourceLike>>>,
           dialect: current.dialect
         }, nextAst, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement) as FromPlanResult<PlanValue, CurrentSource, Dialect>
       }
@@ -5103,7 +5544,9 @@ type AsCurriedResult<
           [sourceName]: {
             name: sourceName,
             mode: "required" as const,
-            baseName: sourceBaseName
+            baseName: sourceBaseName,
+            _presentFormula: trueFormula(),
+            _presenceWitnesses: presenceWitnesses
           }
         }
         const nextAst = {
@@ -5143,7 +5586,7 @@ type AsCurriedResult<
       GroupedOfPlan<PlanValue>,
       ScopedNamesOfPlan<PlanValue>,
       AddExpressionRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, Predicate>,
-      AssumptionsOfPlan<PlanValue>,
+      PlanAssumptionsAfterHaving<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       CapabilitiesOfPlan<PlanValue>,
       StatementOfPlan<PlanValue>
     > => {
@@ -5164,7 +5607,12 @@ type AsCurriedResult<
           kind: "having",
           predicate: predicateExpression
         }]
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement as StatementOfPlan<PlanValue>)
+      }, assumeFormulaTrue(
+        currentQuery.assumptions,
+        formulaOfExpressionRuntime(predicateExpression)
+      ) as PlanAssumptionsAfterHaving<PlanValue, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      currentQuery.capabilities,
+      currentQuery.statement as StatementOfPlan<PlanValue>)
     }
 
   const innerJoin = <CurrentTable extends SourceLike, Predicate extends PredicateInput>(
@@ -5203,7 +5651,13 @@ type AsCurriedResult<
     ): QueryPlan<
       SelectionOfPlan<PlanValue>,
       AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, never, "cross">,
-      AddAvailable<AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, "required">,
+      AddAvailable<
+        AvailableOfPlan<PlanValue>,
+        SourceNameOf<CurrentTable>,
+        "required",
+        TrueFormula,
+        PresenceWitnessKeysOfSource<CurrentTable>
+      >,
       PlanDialectOf<PlanValue> | SourceDialectOf<CurrentTable>,
       GroupedOfPlan<PlanValue>,
       ScopedNamesOfPlan<PlanValue> | SourceNameOf<CurrentTable>,
@@ -5216,6 +5670,7 @@ type AsCurriedResult<
       const currentAst = getAst(plan)
       const currentQuery = getQueryState(plan)
       const { sourceName, sourceBaseName } = sourceDetails(table)
+      const presenceWitnesses = presenceWitnessesOfSourceLike(table)
       const nextAvailable = Object.assign(
         {},
         current.available as AvailableOfPlan<PlanValue>,
@@ -5223,10 +5678,18 @@ type AsCurriedResult<
           [sourceName]: {
             name: sourceName,
             mode: "required",
-            baseName: sourceBaseName
+            baseName: sourceBaseName,
+            _presentFormula: trueFormula(),
+            _presenceWitnesses: presenceWitnesses
           }
         }
-      ) as AddAvailable<AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, "required">
+      ) as AddAvailable<
+        AvailableOfPlan<PlanValue>,
+        SourceNameOf<CurrentTable>,
+        "required",
+        TrueFormula,
+        PresenceWitnessKeysOfSource<CurrentTable>
+      >
       return makePlan({
         selection: current.selection,
         required: currentRequiredList(current.required).filter((name) =>
@@ -5262,12 +5725,18 @@ type AsCurriedResult<
     ): QueryPlan<
       SelectionOfPlan<PlanValue>,
       AddJoinRequired<RequiredOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
-      AvailableAfterJoin<AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Kind>,
+      AvailableAfterJoin<
+        AvailableOfPlan<PlanValue>,
+        SourceNameOf<CurrentTable>,
+        Kind,
+        JoinPresenceFormula<Kind, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+        PresenceWitnessKeysOfSource<CurrentTable>
+      >,
       PlanDialectOf<PlanValue> | SourceDialectOf<CurrentTable> | DialectOfDialectInput<Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       GroupedOfPlan<PlanValue>,
       ScopedNamesOfPlan<PlanValue> | SourceNameOf<CurrentTable>,
       AddJoinRequired<OutstandingOfPlan<PlanValue>, AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Predicate, Kind>,
-      AssumptionsOfPlan<PlanValue>,
+      PlanAssumptionsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
       MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
       StatementOfPlan<PlanValue>
     > => {
@@ -5275,13 +5744,17 @@ type AsCurriedResult<
       const currentAst = getAst(plan)
       const currentQuery = getQueryState(plan)
       const onExpression = toDialectExpression(on)
+      const onFormula = formulaOfExpressionRuntime(onExpression)
       const { sourceName, sourceBaseName } = sourceDetails(table)
+      const presenceWitnesses = presenceWitnessesOfSourceLike(table)
       const baseAvailable = (kind === "right" || kind === "full"
         ? Object.fromEntries(
-          Object.entries(current.available as Record<string, Plan.Source>).map(([name, source]) => [name, {
+          Object.entries(current.available as Record<string, Plan.AnySource>).map(([name, source]) => [name, {
             name: source.name,
             mode: "optional" as const,
-            baseName: source.baseName
+            baseName: source.baseName,
+            _presentFormula: source._presentFormula,
+            _presenceWitnesses: source._presenceWitnesses
           }])
         )
         : current.available) as AvailableOfPlan<PlanValue>
@@ -5290,9 +5763,17 @@ type AsCurriedResult<
         [sourceName]: {
           name: sourceName,
           mode: (kind === "left" || kind === "full" ? "optional" : "required") as JoinSourceMode<Kind>,
-          baseName: sourceBaseName
+          baseName: sourceBaseName,
+          _presentFormula: (kind === "inner" || kind === "left") ? onFormula : trueFormula(),
+          _presenceWitnesses: presenceWitnesses
         }
-      } as AvailableAfterJoin<AvailableOfPlan<PlanValue>, SourceNameOf<CurrentTable>, Kind>
+      } as AvailableAfterJoin<
+        AvailableOfPlan<PlanValue>,
+        SourceNameOf<CurrentTable>,
+        Kind,
+        JoinPresenceFormula<Kind, Predicate, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+        PresenceWitnessKeysOfSource<CurrentTable>
+      >
       return makePlan({
         selection: current.selection,
         required: [...currentRequiredList(current.required), ...extractRequiredFromDialectInputRuntime(on)].filter((name, index, values) =>
@@ -5308,7 +5789,13 @@ type AsCurriedResult<
           source: table,
           on: onExpression
         }]
-      }, currentQuery.assumptions, currentQuery.capabilities as MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>, currentQuery.statement as StatementOfPlan<PlanValue>)
+      }, (
+        kind === "inner"
+          ? assumeFormulaTrue(currentQuery.assumptions, onFormula)
+          : currentQuery.assumptions
+      ) as PlanAssumptionsAfterJoin<PlanValue, Predicate, Kind, Dialect, TextDb, NumericDb, BoolDb, TimestampDb, NullDb>,
+      currentQuery.capabilities as MergeCapabilities<CapabilitiesOfPlan<PlanValue>, SourceCapabilitiesOf<CurrentTable>>,
+      currentQuery.statement as StatementOfPlan<PlanValue>)
     }
 
   const orderBy = <Value extends ExpressionInput>(
@@ -5463,13 +5950,6 @@ type AsCurriedResult<
 
   const distinctOn = ((...values: readonly ExpressionInput[]) => {
     const expressions = values.map((value) => toDialectExpression(value)) as Expression.Any[]
-    if (profile.dialect !== "postgres") {
-      return {
-        __effect_qb_error__: "effect-qb: distinctOn(...) is only supported by the postgres dialect",
-        __effect_qb_dialect__: profile.dialect,
-        __effect_qb_hint__: "Use postgres.Query.distinctOn(...) or regular distinct()/grouping logic"
-      } as DistinctOnUnsupportedError<Dialect>
-    }
     return <PlanValue extends QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
       plan: PlanValue & RequireSelectStatement<PlanValue>
     ): QueryPlan<
@@ -5656,10 +6136,10 @@ type AsCurriedResult<
   >
   function insert<
     Target extends MutationTargetLike,
-    Values extends MutationInputOf<Table.InsertOf<Target>>
+    Values extends Record<string, unknown>
   >(
     target: Target,
-    values: Values
+    values: MutationValuesInput<"insert", Target, Values>
   ): QueryPlan<
     {},
     Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
@@ -5714,55 +6194,6 @@ type AsCurriedResult<
     }, undefined as unknown as TrueFormula, "write", "insert", target, insertState)
   }
 
-  const defaultValues = <
-    Target extends MutationTargetLike
-  >(
-    target: RequiredKeys<Table.InsertOf<Target>> extends never ? Target : DefaultValuesError<Target>
-  ): QueryPlan<
-    {},
-    never,
-    AddAvailable<{}, SourceNameOf<Target>>,
-    TableDialectOf<Target>,
-    never,
-    SourceNameOf<Target>,
-    never,
-    TrueFormula,
-    "write",
-    "insert",
-    Target,
-    "ready"
-  > => {
-    const { sourceName, sourceBaseName } = targetSourceDetails(target as Target)
-    return makePlan({
-      selection: {},
-      required: [] as never,
-      available: {
-        [sourceName]: {
-          name: sourceName,
-          mode: "required",
-          baseName: sourceBaseName
-        }
-      } as AddAvailable<{}, SourceNameOf<Target>>,
-      dialect: (target as Target)[Plan.TypeId].dialect as TableDialectOf<Target>
-    }, {
-      kind: "insert",
-      select: {},
-      into: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target as Target
-      },
-      values: [],
-      conflict: undefined,
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined as unknown as TrueFormula, "write", "insert", target as Target, "ready")
-  }
-
   const attachInsertSource = (
     plan: QueryPlan<any, any, any, any, any, any, any, any, any, "insert", MutationTargetLike, "missing">,
     source: AnyValuesInput | AnyValuesSource | AnyUnnestSource | CompletePlan<QueryPlan<any, any, any, any, any, any, any, any, any, any>>
@@ -5833,7 +6264,7 @@ type AsCurriedResult<
 
   const onConflict = <
     Target extends MutationTargetLike,
-    Columns extends DdlColumnInput,
+    const Columns extends DdlColumnInput,
     UpdateValues extends MutationInputOf<Table.UpdateOf<Target>> | undefined = MutationInputOf<Table.UpdateOf<Target>> | undefined,
     Options extends ConflictActionInput<Target, Dialect, UpdateValues> = ConflictActionInput<Target, Dialect, UpdateValues>
   >(
@@ -5891,37 +6322,37 @@ type AsCurriedResult<
     }
 
   function update<
-    Target extends MutationTargetLike,
-    Values extends MutationInputOf<Table.UpdateOf<Target>>
+    Targets extends MutationTargetTuple,
+    Values extends UpdateInputOfTarget<Targets>
   >(
-    target: Target,
+    target: Dialect extends "mysql" ? Targets : never,
     values: Values
   ): QueryPlan<
     {},
-    Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
-    AddAvailable<{}, SourceNameOf<Target>>,
-    TableDialectOf<Target>,
+    Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
+    AddAvailableMany<{}, MutationTargetNamesOf<Targets>>,
+    TableDialectOf<Targets[0]>,
     never,
-    SourceNameOf<Target>,
-    Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
+    MutationTargetNamesOf<Targets>,
+    Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
     TrueFormula,
     "write",
     "update"
   >
   function update<
-    Targets extends MutationTargetTuple,
-    Values extends UpdateInputOfTarget<Targets>
+    Target extends MutationTargetLike,
+    Values extends Record<string, unknown>
   >(
-    target: Dialect extends "mysql" ? Targets : never,
-    values: Values
+    target: Target,
+    values: MutationValuesInput<"update", Target, Values>
   ): QueryPlan<
     {},
-    Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
-    AddAvailableMany<{}, MutationTargetNamesOf<Targets>>,
-    TableDialectOf<Targets[0]>,
+    Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
+    AddAvailable<{}, SourceNameOf<Target>>,
+    TableDialectOf<Target>,
     never,
-    MutationTargetNamesOf<Targets>,
-    Exclude<NestedMutationRequiredFromValues<Values>, MutationTargetNamesOf<Targets>>,
+    SourceNameOf<Target>,
+    Exclude<MutationRequiredFromValues<Values>, SourceNameOf<Target>>,
     TrueFormula,
     "write",
     "update"
@@ -5959,7 +6390,7 @@ type AsCurriedResult<
   const upsert = <
     Target extends MutationTargetLike,
     Values extends MutationInputOf<Table.InsertOf<Target>>,
-    Columns extends DdlColumnInput,
+    const Columns extends DdlColumnInput,
     UpdateValues extends MutationInputOf<Table.UpdateOf<Target>>
   >(
     target: Target,
@@ -6560,10 +6991,10 @@ type AsCurriedResult<
 
   const createIndex = <
     Target extends SchemaTableLike,
-    Columns extends DdlColumnInput
+    const Columns extends DdlColumnInput
   >(
     target: Target,
-    columns: ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>>,
+    columns: Columns & ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>>,
     options: CreateIndexOptions = {}
   ): QueryPlan<
     {},
@@ -6610,10 +7041,10 @@ type AsCurriedResult<
 
   const dropIndex = <
     Target extends SchemaTableLike,
-    Columns extends DdlColumnInput
+    const Columns extends DdlColumnInput
   >(
     target: Target,
-    columns: ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>>,
+    columns: Columns & ValidateDdlColumns<Target, NormalizeDdlColumns<Columns>>,
     options: DropIndexOptions = {}
   ): QueryPlan<
     {},
@@ -6658,9 +7089,11 @@ type AsCurriedResult<
 
   const api = {
     literal,
+    column,
     cast,
     type,
     json,
+    jsonb,
     eq,
     neq,
     lt,
@@ -6673,6 +7106,10 @@ type AsCurriedResult<
     lower,
     like,
     ilike,
+    regexMatch,
+    regexIMatch,
+    regexNotMatch,
+    regexNotIMatch,
     and,
     or,
     not,
@@ -6681,6 +7118,9 @@ type AsCurriedResult<
     case: case_,
     match,
     coalesce,
+    call,
+    uuidGenerateV4,
+    nextVal,
     in: in_,
     notIn,
     between,
@@ -6711,7 +7151,6 @@ type AsCurriedResult<
     unnest,
     generateSeries,
     returning,
-    defaultValues,
     onConflict,
     insert,
     update,
@@ -6753,5 +7192,5 @@ type AsCurriedResult<
     groupBy
   }
 
-  return api
-}
+return api
+})()