effect-qb 0.13.0 → 0.14.0

package/dist/mysql.js

@@ -22,17 +22,18 @@ __export(exports_column, {
   number: () => number2,
   nullable: () => nullable2,
   json: () => json2,
-  int: () => int2,
+  int: () => int3,
   generated: () => generated2,
   default: () => default_2,
   datetime: () => datetime,
   date: () => date2,
   custom: () => custom2,
+  brand: () => brand5,
   boolean: () => boolean2
 });
 
 // src/internal/column.ts
-import * as Schema2 from "effect/Schema";
+import * as Schema3 from "effect/Schema";
 
 // src/internal/runtime-value.ts
 import * as Schema from "effect/Schema";
@@ -53,6 +54,7 @@ var JsonPrimitiveSchema = Schema.Union(Schema.String, Schema.Number, Schema.Bool
 
 // src/internal/column-state.ts
 import { pipeArguments } from "effect/Pipeable";
+import * as Schema2 from "effect/Schema";
 
 // src/internal/expression.ts
 var exports_expression = {};
@@ -100,6 +102,9 @@ var makeColumnDefinition = (schema, metadata) => {
     references: metadata.references,
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
+    ddlType: metadata.ddlType,
+    identity: metadata.identity,
+    enum: metadata.enum,
     source: undefined,
     dependencies: {}
   };
@@ -132,7 +137,10 @@ var remapColumnDefinition = (column, options = {}) => {
     unique: metadata.unique,
     references: metadata.references,
     defaultValue: metadata.defaultValue,
-    generatedValue: metadata.generatedValue
+    generatedValue: metadata.generatedValue,
+    ddlType: metadata.ddlType,
+    identity: metadata.identity,
+    enum: metadata.enum
   };
   if (TypeId2 in column) {
     next[TypeId2] = column[TypeId2];
@@ -143,13 +151,15 @@ var remapColumnDefinition = (column, options = {}) => {
   return next;
 };
 var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
+  const brandName = `${tableName}.${columnName}`;
+  const schema = column.metadata.brand === true ? Schema2.brand(brandName)(column.schema) : column.schema;
   const bound = Object.create(ColumnProto);
-  bound.schema = column.schema;
+  bound.schema = schema;
   bound.metadata = column.metadata;
   bound[TypeId] = {
     runtime: undefined,
     dbType: column.metadata.dbType,
-    runtimeSchema: column.schema,
+    runtimeSchema: schema,
     nullability: column.metadata.nullable ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
     aggregation: "scalar",
@@ -182,6 +192,7 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
 var mapColumn = (column, metadata) => remapColumnDefinition(column, {
   metadata
 });
+var isColumnDefinitionValue = (value) => typeof value === "object" && value !== null && (ColumnTypeId in value);
 var primitive = (schema, dbType) => makeColumnDefinition(schema, {
   dbType,
   nullable: false,
@@ -195,6 +206,13 @@ var typeFactory = (dialect) => (kind) => ({
   dialect,
   kind
 });
+var postgresType = typeFactory("postgres");
+var renderNumericDdlType = (kind, options) => {
+  if (options === undefined || options.precision === undefined) {
+    return;
+  }
+  return options.scale === undefined ? `${kind}(${options.precision})` : `${kind}(${options.precision},${options.scale})`;
+};
 var makeColumnModule = (dialect, kinds) => {
   const dialectType = typeFactory(dialect);
   return {
@@ -205,13 +223,25 @@ var makeColumnModule = (dialect, kinds) => {
       generated: false,
       primaryKey: false,
       unique: false,
-      references: undefined
+      references: undefined,
+      ddlType: undefined,
+      identity: undefined
     }),
-    uuid: () => primitive(Schema2.UUID, dialectType(kinds.uuid)),
-    text: () => primitive(Schema2.String, dialectType(kinds.text)),
-    int: () => primitive(Schema2.Int, dialectType(kinds.int)),
-    number: () => primitive(DecimalStringSchema, dialectType(kinds.number)),
-    boolean: () => primitive(Schema2.Boolean, dialectType(kinds.boolean)),
+    uuid: () => primitive(Schema3.UUID, dialectType(kinds.uuid)),
+    text: () => primitive(Schema3.String, dialectType(kinds.text)),
+    int: () => primitive(Schema3.Int, dialectType(kinds.int)),
+    number: (options) => makeColumnDefinition(DecimalStringSchema, {
+      dbType: dialectType(kinds.number),
+      nullable: false,
+      hasDefault: false,
+      generated: false,
+      primaryKey: false,
+      unique: false,
+      references: undefined,
+      ddlType: renderNumericDdlType(kinds.number, options),
+      identity: undefined
+    }),
+    boolean: () => primitive(Schema3.Boolean, dialectType(kinds.boolean)),
     date: () => primitive(LocalDateStringSchema, dialectType(kinds.date)),
     timestamp: () => primitive(LocalDateTimeStringSchema, dialectType(kinds.timestamp)),
     json: (schema) => makeColumnDefinition(schema, {
@@ -224,11 +254,13 @@ var makeColumnModule = (dialect, kinds) => {
       generated: false,
       primaryKey: false,
       unique: false,
-      references: undefined
+      references: undefined,
+      ddlType: undefined,
+      identity: undefined
     })
   };
 };
-var postgres = makeColumnModule("postgres", {
+var postgresBase = makeColumnModule("postgres", {
   uuid: "uuid",
   text: "text",
   int: "int4",
@@ -238,6 +270,61 @@ var postgres = makeColumnModule("postgres", {
   timestamp: "timestamp",
   json: "json"
 });
+var postgres = {
+  ...postgresBase,
+  int2: () => primitive(Schema3.Int, postgresType("int2")),
+  int8: () => primitive(BigIntStringSchema, postgresType("int8")),
+  float4: () => primitive(Schema3.Number, postgresType("float4")),
+  float8: () => primitive(Schema3.Number, postgresType("float8")),
+  char: (length = 1) => makeColumnDefinition(Schema3.String, {
+    dbType: postgresType("char"),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: `char(${length})`,
+    identity: undefined
+  }),
+  varchar: (length) => makeColumnDefinition(Schema3.String, {
+    dbType: postgresType("varchar"),
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: length === undefined ? "varchar" : `varchar(${length})`,
+    identity: undefined
+  }),
+  time: () => primitive(LocalTimeStringSchema, postgresType("time")),
+  timetz: () => primitive(OffsetTimeStringSchema, postgresType("timetz")),
+  timestamptz: () => primitive(InstantStringSchema, postgresType("timestamptz")),
+  interval: () => primitive(Schema3.String, postgresType("interval")),
+  bytea: () => primitive(Schema3.Uint8ArrayFromSelf, postgresType("bytea")),
+  name: () => primitive(Schema3.String, postgresType("name")),
+  oid: () => primitive(Schema3.Int, postgresType("oid")),
+  regclass: () => primitive(Schema3.String, postgresType("regclass")),
+  bit: () => primitive(Schema3.String, postgresType("bit")),
+  varbit: () => primitive(Schema3.String, postgresType("varbit")),
+  xml: () => primitive(Schema3.String, postgresType("xml")),
+  pg_lsn: () => primitive(Schema3.String, postgresType("pg_lsn")),
+  jsonb: (schema) => makeColumnDefinition(schema, {
+    dbType: {
+      ...postgresType("jsonb"),
+      variant: "jsonb"
+    },
+    nullable: false,
+    hasDefault: false,
+    generated: false,
+    primaryKey: false,
+    unique: false,
+    references: undefined,
+    ddlType: undefined,
+    identity: undefined
+  })
+};
 var mysql = makeColumnModule("mysql", {
   uuid: "uuid",
   text: "text",
@@ -251,15 +338,53 @@ var mysql = makeColumnModule("mysql", {
 var uuid = postgres.uuid;
 var text = postgres.text;
 var int = postgres.int;
+var int2 = postgres.int2;
+var int8 = postgres.int8;
 var number = postgres.number;
+var float4 = postgres.float4;
+var float8 = postgres.float8;
 var boolean = postgres.boolean;
 var date = postgres.date;
 var timestamp = postgres.timestamp;
+var time = postgres.time;
+var timetz = postgres.timetz;
+var timestamptz = postgres.timestamptz;
+var char = postgres.char;
+var varchar = postgres.varchar;
+var interval = postgres.interval;
+var bytea = postgres.bytea;
+var name = postgres.name;
+var oid = postgres.oid;
+var regclass = postgres.regclass;
+var bit = postgres.bit;
+var varbit = postgres.varbit;
+var xml = postgres.xml;
+var pg_lsn = postgres.pg_lsn;
 var json = postgres.json;
+var jsonb = postgres.jsonb;
 var custom = postgres.custom;
 var schema = (nextSchema) => (column) => remapColumnDefinition(column, {
   schema: nextSchema
 });
+var brand4 = (column) => {
+  if (BoundColumnTypeId in column) {
+    const boundColumn = column;
+    const brandName = `${boundColumn[BoundColumnTypeId].tableName}.${boundColumn[BoundColumnTypeId].columnName}`;
+    return remapColumnDefinition(boundColumn, {
+      schema: Schema3.brand(brandName)(boundColumn.schema),
+      metadata: {
+        ...boundColumn.metadata,
+        brand: true
+      }
+    });
+  }
+  return remapColumnDefinition(column, {
+    metadata: {
+      ...column.metadata,
+      brand: true
+    }
+  });
+};
 var nullable = (column) => mapColumn(column, {
   ...column.metadata,
   nullable: true
@@ -270,32 +395,100 @@ var primaryKey = (column) => mapColumn(column, {
   primaryKey: true,
   unique: true
 });
-var unique = (column) => mapColumn(column, {
+var unique = Object.assign((column) => mapColumn(column, {
   ...column.metadata,
   unique: true
+}), {
+  options: (options) => (column) => mapColumn(column, {
+    ...column.metadata,
+    unique: true,
+    uniqueConstraint: options
+  })
 });
 var default_ = (value) => (column) => mapColumn(column, {
   ...column.metadata,
   hasDefault: true,
   defaultValue: value,
-  generatedValue: undefined
+  generatedValue: undefined,
+  identity: undefined
 });
 var generated = (value) => (column) => mapColumn(column, {
   ...column.metadata,
   generated: true,
   hasDefault: false,
   defaultValue: undefined,
-  generatedValue: value
+  generatedValue: value,
+  identity: undefined
 });
-var references = (target) => (column) => mapColumn(column, {
+var ddlType = (sqlType) => (column) => mapColumn(column, {
   ...column.metadata,
-  references: { target }
+  ddlType: sqlType
 });
+var array = (options) => (column) => remapColumnDefinition(column, {
+  schema: Schema3.Array(options?.nullableElements ? Schema3.NullOr(column.schema) : column.schema),
+  metadata: {
+    ...column.metadata,
+    dbType: {
+      dialect: column.metadata.dbType.dialect,
+      kind: `${column.metadata.dbType.kind}[]`,
+      element: column.metadata.dbType
+    },
+    ddlType: `${column.metadata.ddlType ?? column.metadata.dbType.kind}[]`
+  }
+});
+function index(arg) {
+  if (isColumnDefinitionValue(arg)) {
+    return mapColumn(arg, {
+      ...arg.metadata,
+      index: arg.metadata.index ?? {}
+    });
+  }
+  const options = arg ?? {};
+  return (column) => mapColumn(column, {
+    ...column.metadata,
+    index: options
+  });
+}
+var identityByDefault = (column) => mapColumn(column, {
+  ...column.metadata,
+  hasDefault: true,
+  generated: false,
+  defaultValue: undefined,
+  generatedValue: undefined,
+  identity: {
+    generation: "byDefault"
+  }
+});
+var identityAlways = (column) => mapColumn(column, {
+  ...column.metadata,
+  hasDefault: false,
+  generated: true,
+  defaultValue: undefined,
+  generatedValue: undefined,
+  identity: {
+    generation: "always"
+  }
+});
+function foreignKey(arg) {
+  if (typeof arg === "function") {
+    const target = arg;
+    return (column) => mapColumn(column, {
+      ...column.metadata,
+      references: { target }
+    });
+  }
+  const options = arg;
+  return (column) => mapColumn(column, {
+    ...column.metadata,
+    references: options
+  });
+}
+var references = (target) => foreignKey(target);
 
 // src/mysql/column.ts
 var uuid2 = mysql.uuid;
 var text2 = mysql.text;
-var int2 = mysql.int;
+var int3 = mysql.int;
 var number2 = mysql.number;
 var boolean2 = mysql.boolean;
 var date2 = mysql.date;
@@ -304,6 +497,7 @@ var timestamp2 = mysql.timestamp;
 var json2 = mysql.json;
 var custom2 = mysql.custom;
 var nullable2 = nullable;
+var brand5 = brand4;
 var primaryKey2 = primaryKey;
 var unique2 = unique;
 var default_2 = default_;
@@ -316,29 +510,6 @@ __export(exports_datatypes, {
   mysqlDatatypes: () => mysqlDatatypes
 });
 
-// src/internal/datatypes/define.ts
-var makeDatatypeModule = (dialect, kinds, aliases) => {
-  const module = {
-    custom: (kind) => ({
-      dialect,
-      kind
-    })
-  };
-  for (const kind of Object.keys(kinds)) {
-    module[kind] = () => ({
-      dialect,
-      kind
-    });
-  }
-  for (const [alias, kind] of Object.entries(aliases ?? {})) {
-    module[alias] = () => ({
-      dialect,
-      kind
-    });
-  }
-  return module;
-};
-
 // src/mysql/datatypes/spec.ts
 var mysqlDatatypeKinds = {
   char: { family: "text", runtime: "string" },
@@ -388,7 +559,19 @@ var mysqlDatatypeKinds = {
 };
 
 // src/mysql/datatypes/index.ts
-var mysqlDatatypes = makeDatatypeModule("mysql", mysqlDatatypeKinds);
+var mysqlDatatypeModule = {
+  custom: (kind) => ({
+    dialect: "mysql",
+    kind
+  })
+};
+for (const kind of Object.keys(mysqlDatatypeKinds)) {
+  mysqlDatatypeModule[kind] = () => ({
+    dialect: "mysql",
+    kind
+  });
+}
+var mysqlDatatypes = mysqlDatatypeModule;
 // src/mysql/errors/index.ts
 var exports_errors = {};
 __export(exports_errors, {
@@ -52189,18 +52372,20 @@ __export(exports_function, {
   core: () => exports_core,
   concat: () => concat,
   coalesce: () => coalesce,
+  call: () => call,
   aggregate: () => exports_aggregate
 });
 
 // src/mysql/function/core.ts
 var exports_core = {};
 __export(exports_core, {
-  coalesce: () => coalesce
+  coalesce: () => coalesce,
+  call: () => call
 });
 
-// src/internal/query-factory.ts
+// src/internal/mysql-query.ts
 import { pipeArguments as pipeArguments5 } from "effect/Pipeable";
-import * as Schema4 from "effect/Schema";
+import * as Schema5 from "effect/Schema";
 
 // src/internal/plan.ts
 var exports_plan = {};
@@ -52232,7 +52417,11 @@ var collectInlineOptions = (fields2) => {
     if (column.metadata.unique && !column.metadata.primaryKey) {
       options.push({
         kind: "unique",
-        columns: [columnName]
+        columns: [columnName],
+        name: column.metadata.uniqueConstraint?.name,
+        nullsNotDistinct: column.metadata.uniqueConstraint?.nullsNotDistinct,
+        deferrable: column.metadata.uniqueConstraint?.deferrable,
+        initiallyDeferred: column.metadata.uniqueConstraint?.initiallyDeferred
       });
     }
     if (column.metadata.references) {
@@ -52248,7 +52437,27 @@ var collectInlineOptions = (fields2) => {
             schemaName: bound.schemaName,
             columns: [bound.columnName]
           };
-        }
+        },
+        name: column.metadata.references.name,
+        onUpdate: column.metadata.references.onUpdate,
+        onDelete: column.metadata.references.onDelete,
+        deferrable: column.metadata.references.deferrable,
+        initiallyDeferred: column.metadata.references.initiallyDeferred
+      });
+    }
+    if (column.metadata.index) {
+      options.push({
+        kind: "index",
+        keys: [{
+          kind: "column",
+          column: columnName,
+          order: column.metadata.index.order,
+          nulls: column.metadata.index.nulls
+        }],
+        name: column.metadata.index.name,
+        method: column.metadata.index.method,
+        include: column.metadata.index.include,
+        predicate: column.metadata.index.predicate
       });
     }
   }
@@ -52280,17 +52489,18 @@ var validateOptions = (tableName, fields2, options) => {
       case "primaryKey":
       case "unique":
       case "foreignKey": {
-        if (option.columns.length === 0) {
+        const columns = option.kind === "index" ? option.columns ?? [] : option.columns;
+        if (columns.length === 0 && option.kind !== "index") {
           throw new Error(`Option '${option.kind}' on table '${tableName}' requires at least one column`);
         }
-        for (const column of option.columns) {
+        for (const column of columns) {
           if (!knownColumns.has(column)) {
             throw new Error(`Unknown column '${column}' on table '${tableName}'`);
           }
         }
         if (option.kind === "foreignKey") {
           const reference = option.references();
-          if (reference.columns.length !== option.columns.length) {
+          if (reference.columns.length !== columns.length) {
             throw new Error(`Foreign key on table '${tableName}' must reference the same number of columns`);
           }
           if (reference.knownColumns) {
@@ -52302,6 +52512,21 @@ var validateOptions = (tableName, fields2, options) => {
             }
           }
         }
+        if (option.kind === "index") {
+          for (const column of option.include ?? []) {
+            if (!knownColumns.has(column)) {
+              throw new Error(`Unknown included column '${column}' on table '${tableName}'`);
+            }
+          }
+          for (const key of option.keys ?? []) {
+            if (key.kind === "column" && !knownColumns.has(key.column)) {
+              throw new Error(`Unknown index key column '${key.column}' on table '${tableName}'`);
+            }
+          }
+          if (option.columns === undefined && (option.keys === undefined || option.keys.length === 0)) {
+            throw new Error(`Index on table '${tableName}' requires at least one column or key`);
+          }
+        }
         break;
       }
       case "check": {
@@ -52318,37 +52543,38 @@ var validateOptions = (tableName, fields2, options) => {
 
 // src/internal/schema-derivation.ts
 import * as VariantSchema from "@effect/experimental/VariantSchema";
-import * as Schema3 from "effect/Schema";
+import * as Schema4 from "effect/Schema";
 var TableSchema = VariantSchema.make({
   variants: ["select", "insert", "update"],
   defaultVariant: "select"
 });
-var selectSchema = (column) => column.metadata.nullable ? Schema3.NullOr(column.schema) : column.schema;
-var insertSchema = (column) => {
+var maybeBrandSchema = (column, tableName, columnName) => column.metadata.brand === true ? Schema4.brand(`${tableName}.${columnName}`)(column.schema) : column.schema;
+var selectSchema = (column, tableName, columnName) => column.metadata.nullable ? Schema4.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
+var insertSchema = (column, tableName, columnName) => {
   if (column.metadata.generated) {
     return;
   }
-  const base = column.metadata.nullable ? Schema3.NullOr(column.schema) : column.schema;
-  return column.metadata.nullable || column.metadata.hasDefault ? Schema3.optional(base) : base;
+  const base = column.metadata.nullable ? Schema4.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
+  return column.metadata.nullable || column.metadata.hasDefault ? Schema4.optional(base) : base;
 };
-var updateSchema = (column, isPrimaryKey) => {
+var updateSchema = (column, tableName, columnName, isPrimaryKey) => {
   if (column.metadata.generated || isPrimaryKey) {
     return;
   }
-  const base = column.metadata.nullable ? Schema3.NullOr(column.schema) : column.schema;
-  return Schema3.optional(base);
+  const base = column.metadata.nullable ? Schema4.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
+  return Schema4.optional(base);
 };
-var deriveSchemas = (fields2, primaryKeyColumns) => {
+var deriveSchemas = (tableName, fields2, primaryKeyColumns) => {
   const primaryKeySet = new Set(primaryKeyColumns);
   const variants = {};
   for (const [key, column] of Object.entries(fields2)) {
     const config = {
-      select: selectSchema(column),
+      select: selectSchema(column, tableName, key),
       insert: undefined,
       update: undefined
     };
-    const insert = insertSchema(column);
-    const update = updateSchema(column, primaryKeySet.has(key));
+    const insert = insertSchema(column, tableName, key);
+    const update = updateSchema(column, tableName, key, primaryKeySet.has(key));
     if (insert !== undefined) {
       config.insert = insert;
     } else {
@@ -52380,13 +52606,13 @@ var TableProto = {
     return pipeArguments2(this, arguments);
   }
 };
-var buildArtifacts = (name, fields2, declaredOptions, schemaName) => {
+var buildArtifacts = (name2, fields2, declaredOptions, schemaName) => {
   const normalizedOptions = [...collectInlineOptions(fields2), ...declaredOptions];
-  validateFieldDialects(name, fields2);
-  validateOptions(name, fields2, declaredOptions);
+  validateFieldDialects(name2, fields2);
+  validateOptions(name2, fields2, declaredOptions);
   const primaryKey3 = resolvePrimaryKeyColumns(fields2, declaredOptions);
-  const columns = Object.fromEntries(Object.entries(fields2).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)]));
-  const schemas = deriveSchemas(fields2, primaryKey3);
+  const columns = Object.fromEntries(Object.entries(fields2).map(([key, column]) => [key, bindColumn(name2, key, column, name2, schemaName)]));
+  const schemas = deriveSchemas(name2, fields2, primaryKey3);
   return {
     columns,
     schemas,
@@ -52394,16 +52620,16 @@ var buildArtifacts = (name, fields2, declaredOptions, schemaName) => {
     primaryKey: primaryKey3
   };
 };
-var makeTable = (name, fields2, declaredOptions, baseName = name, kind = "schema", schemaName, schemaMode = "default") => {
+var makeTable = (name2, fields2, declaredOptions, baseName = name2, kind = "schema", schemaName, schemaMode = "default") => {
   const resolvedSchemaName = schemaMode === "explicit" ? schemaName : "public";
-  const artifacts = buildArtifacts(name, fields2, declaredOptions, resolvedSchemaName);
+  const artifacts = buildArtifacts(name2, fields2, declaredOptions, resolvedSchemaName);
   const dialect = resolveFieldDialect(fields2);
   const table = Object.create(TableProto);
-  table.name = name;
+  table.name = name2;
   table.columns = artifacts.columns;
   table.schemas = artifacts.schemas;
   table[TypeId4] = {
-    name,
+    name: name2,
     baseName,
     schemaName: resolvedSchemaName,
     fields: fields2,
@@ -52414,8 +52640,8 @@ var makeTable = (name, fields2, declaredOptions, baseName = name, kind = "schema
     selection: artifacts.columns,
     required: undefined,
     available: {
-      [name]: {
-        name,
+      [name2]: {
+        name: name2,
         mode: "required",
         baseName
       }
@@ -52433,6 +52659,12 @@ var makeTable = (name, fields2, declaredOptions, baseName = name, kind = "schema
   return table;
 };
 var extractDeclaredOptions = (declaredOptions) => declaredOptions?.map((option) => option.option) ?? [];
+var applyDeclaredOptions = (table, declaredOptions) => {
+  if (declaredOptions === undefined || declaredOptions.length === 0) {
+    return table;
+  }
+  return declaredOptions.reduce((current, option) => option(current), table);
+};
 var validateClassOptions = (declaredOptions) => {
   for (const option of declaredOptions) {
     if (option.kind === "primaryKey") {
@@ -52463,9 +52695,15 @@ var ensureClassArtifacts = (self) => {
     return cached;
   }
   const state = self[TypeId4];
-  const declaredOptions = extractDeclaredOptions(self[options]);
-  validateClassOptions(declaredOptions);
-  const artifacts = buildArtifacts(state.name, state.fields, declaredOptions, state.schemaName);
+  const classOptions = self[options];
+  validateClassOptions(extractDeclaredOptions(classOptions));
+  const table = applyDeclaredOptions(makeTable(state.name, state.fields, [], state.name, "schema", state.schemaName, state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit"), classOptions);
+  const artifacts = {
+    columns: table.columns,
+    schemas: table.schemas,
+    normalizedOptions: table[OptionsSymbol],
+    primaryKey: table[TypeId4].primaryKey
+  };
   Object.defineProperty(self, CacheSymbol, {
     configurable: true,
     value: artifacts
@@ -52484,13 +52722,14 @@ var makeOption = (option) => {
   builder.option = option;
   return builder;
 };
-function make2(name, fields2, schemaName) {
+var option = (spec) => makeOption(spec);
+function make2(name2, fields2, schemaName) {
   const resolvedSchemaName = arguments.length >= 3 ? schemaName : "public";
-  return makeTable(name, fields2, [], name, "schema", resolvedSchemaName, arguments.length >= 3 ? "explicit" : "default");
+  return makeTable(name2, fields2, [], name2, "schema", resolvedSchemaName, arguments.length >= 3 ? "explicit" : "default");
 }
 var schema3 = (schemaName) => ({
   schemaName,
-  table: (name, fields2, ...options2) => makeTable(name, fields2, extractDeclaredOptions(options2), name, "schema", schemaName, "explicit")
+  table: (name2, fields2, ...options2) => applyDeclaredOptions(makeTable(name2, fields2, [], name2, "schema", schemaName, "explicit"), options2)
 });
 var alias = (table, aliasName) => {
   const state = table[TypeId4];
@@ -52498,7 +52737,7 @@ var alias = (table, aliasName) => {
   const aliased = Object.create(TableProto);
   aliased.name = aliasName;
   aliased.columns = columns;
-  aliased.schemas = table.schemas;
+  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey);
   aliased[TypeId4] = {
     name: aliasName,
     baseName: state.baseName,
@@ -52529,12 +52768,12 @@ var alias = (table, aliasName) => {
   }
   return aliased;
 };
-function Class(name, schemaName) {
+function Class(name2, schemaName) {
   const resolvedSchemaName = arguments.length >= 2 ? schemaName : "public";
   return (fields2) => {
 
     class TableClassBase {
-      static tableName = name;
+      static tableName = name2;
       static get columns() {
         return ensureClassArtifacts(this).columns;
       }
@@ -52545,8 +52784,8 @@ function Class(name, schemaName) {
         const declaredOptions = extractDeclaredOptions(this[options]);
         validateClassOptions(declaredOptions);
         return {
-          name,
-          baseName: name,
+          name: name2,
+          baseName: name2,
           schemaName: resolvedSchemaName,
           fields: fields2,
           primaryKey: resolvePrimaryKeyColumns(fields2, collectInlineOptions(fields2)),
@@ -52559,10 +52798,10 @@ function Class(name, schemaName) {
           selection: artifacts.columns,
           required: undefined,
           available: {
-            [name]: {
-              name,
+            [name2]: {
+              name: name2,
               mode: "required",
-              baseName: name
+              baseName: name2
             }
           },
           dialect: resolveFieldDialect(fields2)
@@ -52595,11 +52834,11 @@ var unique3 = (columns) => makeOption({
   kind: "unique",
   columns: normalizeColumnList(columns)
 });
-var index = (columns) => makeOption({
+var index2 = (columns) => makeOption({
   kind: "index",
   columns: normalizeColumnList(columns)
 });
-var foreignKey = (columns, target, referencedColumns) => makeOption({
+var foreignKey2 = (columns, target, referencedColumns) => makeOption({
   kind: "foreignKey",
   columns: normalizeColumnList(columns),
   references: () => ({
@@ -52609,9 +52848,9 @@ var foreignKey = (columns, target, referencedColumns) => makeOption({
     knownColumns: Object.keys(target()[TypeId4].fields)
   })
 });
-var check = (name, predicate) => makeOption({
+var check = (name2, predicate) => makeOption({
   kind: "check",
-  name,
+  name: name2,
   predicate
 });
 
@@ -52621,6 +52860,535 @@ import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
 // src/internal/query-ast.ts
 var TypeId5 = Symbol.for("effect-qb/QueryAst");
 
+// src/internal/predicate-runtime.ts
+var trueFormula = () => ({ kind: "true" });
+var falseFormula = () => ({ kind: "false" });
+var atomFormula = (atom) => ({ kind: "atom", atom });
+var allFormula = (items) => normalizeFormula({ kind: "all", items });
+var anyFormula = (items) => normalizeFormula({ kind: "any", items });
+var notFormula = (item) => normalizeFormula({ kind: "not", item });
+var andFormula = (left, right) => allFormula([left, right]);
+var unknownTag = (tag) => atomFormula({ kind: "unknown", tag });
+var emptyContext = () => ({
+  nonNullKeys: new Set,
+  nullKeys: new Set,
+  eqLiterals: new Map,
+  neqLiterals: new Map,
+  sourceNames: new Set,
+  contradiction: false,
+  unknown: false
+});
+var cloneContext = (context) => ({
+  nonNullKeys: new Set(context.nonNullKeys),
+  nullKeys: new Set(context.nullKeys),
+  eqLiterals: new Map(context.eqLiterals),
+  neqLiterals: new Map(Array.from(context.neqLiterals.entries(), ([key, values]) => [key, new Set(values)])),
+  sourceNames: new Set(context.sourceNames),
+  contradiction: context.contradiction,
+  unknown: context.unknown
+});
+var freezeContext = (context) => context;
+var sourceNameOfKey = (key) => key.split(".", 1)[0] ?? key;
+var addSourceName = (context, key) => {
+  context.sourceNames.add(sourceNameOfKey(key));
+};
+var addNonNull = (context, key) => {
+  addSourceName(context, key);
+  if (context.nullKeys.has(key)) {
+    context.contradiction = true;
+  }
+  context.nonNullKeys.add(key);
+};
+var addNull = (context, key) => {
+  addSourceName(context, key);
+  if (context.nonNullKeys.has(key)) {
+    context.contradiction = true;
+  }
+  context.nullKeys.add(key);
+};
+var addEqLiteral = (context, key, value) => {
+  addNonNull(context, key);
+  const existing = context.eqLiterals.get(key);
+  if (existing !== undefined && existing !== value) {
+    context.contradiction = true;
+  }
+  const neqValues = context.neqLiterals.get(key);
+  if (neqValues?.has(value)) {
+    context.contradiction = true;
+  }
+  context.eqLiterals.set(key, value);
+};
+var addNeqLiteral = (context, key, value) => {
+  addNonNull(context, key);
+  if (context.eqLiterals.get(key) === value) {
+    context.contradiction = true;
+  }
+  const values = context.neqLiterals.get(key) ?? new Set;
+  values.add(value);
+  context.neqLiterals.set(key, values);
+};
+var applyEqColumn = (context, left, right) => {
+  const leftValue = context.eqLiterals.get(left);
+  const rightValue = context.eqLiterals.get(right);
+  if (leftValue === undefined && rightValue === undefined) {
+    addNonNull(context, left);
+    addNonNull(context, right);
+    return;
+  }
+  if (leftValue === undefined && rightValue !== undefined) {
+    addNonNull(context, left);
+    addEqLiteral(context, left, rightValue);
+    return;
+  }
+  if (leftValue !== undefined && rightValue === undefined) {
+    addNonNull(context, right);
+    addEqLiteral(context, right, leftValue);
+    return;
+  }
+  if (leftValue === rightValue) {
+    addEqLiteral(context, left, leftValue);
+    addEqLiteral(context, right, rightValue);
+    return;
+  }
+  context.contradiction = true;
+};
+var applyAtom = (context, atom) => {
+  switch (atom.kind) {
+    case "is-null":
+      addNull(context, atom.key);
+      return;
+    case "is-not-null":
+      addNonNull(context, atom.key);
+      return;
+    case "eq-literal":
+      addEqLiteral(context, atom.key, atom.value);
+      return;
+    case "neq-literal":
+      addNeqLiteral(context, atom.key, atom.value);
+      return;
+    case "eq-column":
+      applyEqColumn(context, atom.left, atom.right);
+      return;
+    case "unknown":
+      context.unknown = true;
+      return;
+  }
+};
+var applyNegativeAtom = (context, atom) => {
+  switch (atom.kind) {
+    case "is-null":
+      addNonNull(context, atom.key);
+      return;
+    case "is-not-null":
+      addNull(context, atom.key);
+      return;
+    case "eq-literal":
+      addNeqLiteral(context, atom.key, atom.value);
+      return;
+    case "neq-literal":
+      addEqLiteral(context, atom.key, atom.value);
+      return;
+    case "eq-column":
+      addNonNull(context, atom.left);
+      addNonNull(context, atom.right);
+      return;
+    case "unknown":
+      context.unknown = true;
+      return;
+  }
+};
+var intersectEqLiterals = (left, right) => {
+  const result = new Map;
+  for (const [key, value] of left) {
+    if (right.get(key) === value) {
+      result.set(key, value);
+    }
+  }
+  return result;
+};
+var intersectNeqLiterals = (left, right) => {
+  const result = new Map;
+  for (const [key, leftValues] of left) {
+    const rightValues = right.get(key);
+    if (rightValues === undefined) {
+      continue;
+    }
+    const next = new Set(Array.from(leftValues).filter((value) => rightValues.has(value)));
+    if (next.size > 0) {
+      result.set(key, next);
+    }
+  }
+  return result;
+};
+var intersectContexts = (left, right) => {
+  if (left.contradiction) {
+    return cloneContext(right);
+  }
+  if (right.contradiction) {
+    return cloneContext(left);
+  }
+  return {
+    nonNullKeys: new Set(Array.from(left.nonNullKeys).filter((key) => right.nonNullKeys.has(key))),
+    nullKeys: new Set(Array.from(left.nullKeys).filter((key) => right.nullKeys.has(key))),
+    eqLiterals: intersectEqLiterals(left.eqLiterals, right.eqLiterals),
+    neqLiterals: intersectNeqLiterals(left.neqLiterals, right.neqLiterals),
+    sourceNames: new Set(Array.from(left.sourceNames).filter((name2) => right.sourceNames.has(name2))),
+    contradiction: false,
+    unknown: left.unknown || right.unknown
+  };
+};
+var analyzeBranchSet = (context, items, polarity) => {
+  let current;
+  for (const item of items) {
+    const branch = analyzeStack(cloneContext(context), [{ formula: item, polarity }]);
+    if (branch.contradiction) {
+      continue;
+    }
+    current = current === undefined ? branch : intersectContexts(current, branch);
+  }
+  if (current === undefined) {
+    const next = cloneContext(context);
+    next.contradiction = true;
+    return next;
+  }
+  return current;
+};
+var analyzeStack = (context, stack) => {
+  const queue = [...stack];
+  while (queue.length > 0 && !context.contradiction) {
+    const frame = queue.shift();
+    switch (frame.formula.kind) {
+      case "true":
+        if (frame.polarity === "negative") {
+          context.contradiction = true;
+        }
+        break;
+      case "false":
+        if (frame.polarity === "positive") {
+          context.contradiction = true;
+        }
+        break;
+      case "atom":
+        if (frame.polarity === "positive") {
+          applyAtom(context, frame.formula.atom);
+        } else {
+          applyNegativeAtom(context, frame.formula.atom);
+        }
+        break;
+      case "not":
+        queue.unshift({
+          formula: frame.formula.item,
+          polarity: frame.polarity === "positive" ? "negative" : "positive"
+        });
+        break;
+      case "all":
+        if (frame.polarity === "positive") {
+          queue.unshift(...frame.formula.items.map((formula) => ({ formula, polarity: "positive" })));
+        } else {
+          context = analyzeBranchSet(context, frame.formula.items, "negative");
+        }
+        break;
+      case "any":
+        if (frame.polarity === "positive") {
+          context = analyzeBranchSet(context, frame.formula.items, "positive");
+        } else {
+          queue.unshift(...frame.formula.items.map((formula) => ({ formula, polarity: "negative" })));
+        }
+        break;
+    }
+  }
+  return context;
+};
+var analyzeFormula = (formula) => freezeContext(analyzeStack(emptyContext(), [{ formula, polarity: "positive" }]));
+var astOf = (value) => value[TypeId2];
+var columnKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  return ast.kind === "column" ? `${ast.tableName}.${ast.columnName}` : undefined;
+};
+var valueKeyOfLiteral = (value) => {
+  if (typeof value === "string") {
+    return `string:${value}`;
+  }
+  if (typeof value === "number") {
+    return `number:${value}`;
+  }
+  if (typeof value === "boolean") {
+    return `boolean:${value}`;
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (value instanceof Date) {
+    return `date:${value.toISOString()}`;
+  }
+  return "unknown";
+};
+var nonNullFactsOfExpression = (value) => {
+  const key = columnKeyOfExpression(value);
+  return key === undefined ? undefined : atomFormula({ kind: "is-not-null", key });
+};
+var combineFacts = (left, right) => {
+  if (left === undefined) {
+    return right ?? trueFormula();
+  }
+  if (right === undefined) {
+    return left;
+  }
+  return andFormula(left, right);
+};
+var formulaOfEq = (left, right) => {
+  const leftKey = columnKeyOfExpression(left);
+  const rightKey = columnKeyOfExpression(right);
+  const leftAst = astOf(left);
+  const rightAst = astOf(right);
+  const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
+  const rightLiteral = rightAst.kind === "literal" ? rightAst.value : undefined;
+  if (leftKey === undefined && rightKey === undefined) {
+    if (leftAst.kind !== "literal" || rightAst.kind !== "literal") {
+      return unknownTag("eq:unsupported");
+    }
+    if (leftLiteral === null || rightLiteral === null) {
+      return falseFormula();
+    }
+    return Object.is(leftLiteral, rightLiteral) ? trueFormula() : falseFormula();
+  }
+  if (leftKey === undefined) {
+    if (leftAst.kind !== "literal") {
+      return unknownTag("eq:unsupported");
+    }
+    if (leftLiteral === null) {
+      return falseFormula();
+    }
+    return atomFormula({
+      kind: "eq-literal",
+      key: rightKey,
+      value: valueKeyOfLiteral(leftLiteral)
+    });
+  }
+  if (rightKey === undefined) {
+    if (rightAst.kind !== "literal") {
+      return unknownTag("eq:unsupported");
+    }
+    if (rightLiteral === null) {
+      return falseFormula();
+    }
+    return atomFormula({
+      kind: "eq-literal",
+      key: leftKey,
+      value: valueKeyOfLiteral(rightLiteral)
+    });
+  }
+  return atomFormula({
+    kind: "eq-column",
+    left: leftKey,
+    right: rightKey
+  });
+};
+var formulaOfNeq = (left, right) => {
+  const leftKey = columnKeyOfExpression(left);
+  const rightKey = columnKeyOfExpression(right);
+  const leftAst = astOf(left);
+  const rightAst = astOf(right);
+  const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
+  const rightLiteral = rightAst.kind === "literal" ? rightAst.value : undefined;
+  if (leftKey === undefined && rightKey === undefined) {
+    if (leftAst.kind !== "literal" || rightAst.kind !== "literal") {
+      return unknownTag("neq:unsupported");
+    }
+    if (leftLiteral === null || rightLiteral === null) {
+      return falseFormula();
+    }
+    return Object.is(leftLiteral, rightLiteral) ? falseFormula() : trueFormula();
+  }
+  if (leftKey === undefined) {
+    if (leftAst.kind !== "literal") {
+      return unknownTag("neq:unsupported");
+    }
+    if (leftLiteral === null) {
+      return falseFormula();
+    }
+    return atomFormula({
+      kind: "neq-literal",
+      key: rightKey,
+      value: valueKeyOfLiteral(leftLiteral)
+    });
+  }
+  if (rightKey === undefined) {
+    if (rightAst.kind !== "literal") {
+      return unknownTag("neq:unsupported");
+    }
+    if (rightLiteral === null) {
+      return falseFormula();
+    }
+    return atomFormula({
+      kind: "neq-literal",
+      key: leftKey,
+      value: valueKeyOfLiteral(rightLiteral)
+    });
+  }
+  return combineFacts(nonNullFactsOfExpression(left), nonNullFactsOfExpression(right));
+};
+var formulaOfIsNotDistinctFrom = (left, right) => {
+  const leftKey = columnKeyOfExpression(left);
+  const rightKey = columnKeyOfExpression(right);
+  const leftAst = astOf(left);
+  const rightAst = astOf(right);
+  const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
+  const rightLiteral = rightAst.kind === "literal" ? rightAst.value : undefined;
+  if (leftAst.kind === "literal" && rightAst.kind === "literal") {
+    return Object.is(leftLiteral, rightLiteral) ? trueFormula() : falseFormula();
+  }
+  if (leftAst.kind === "literal" && leftLiteral === null && rightKey !== undefined) {
+    return atomFormula({ kind: "is-null", key: rightKey });
+  }
+  if (rightAst.kind === "literal" && rightLiteral === null && leftKey !== undefined) {
+    return atomFormula({ kind: "is-null", key: leftKey });
+  }
+  if (leftAst.kind === "literal" && rightKey !== undefined) {
+    return atomFormula({
+      kind: "eq-literal",
+      key: rightKey,
+      value: valueKeyOfLiteral(leftLiteral)
+    });
+  }
+  if (rightAst.kind === "literal" && leftKey !== undefined) {
+    return atomFormula({
+      kind: "eq-literal",
+      key: leftKey,
+      value: valueKeyOfLiteral(rightLiteral)
+    });
+  }
+  return unknownTag("isNotDistinctFrom:unsupported");
+};
+var normalizeFormula = (formula) => {
+  switch (formula.kind) {
+    case "all": {
+      const items = [];
+      for (const item of formula.items) {
+        const normalized = normalizeFormula(item);
+        if (normalized.kind === "true") {
+          continue;
+        }
+        if (normalized.kind === "false") {
+          return falseFormula();
+        }
+        if (normalized.kind === "all") {
+          items.push(...normalized.items);
+        } else {
+          items.push(normalized);
+        }
+      }
+      if (items.length === 0) {
+        return trueFormula();
+      }
+      if (items.length === 1) {
+        return items[0];
+      }
+      return { kind: "all", items };
+    }
+    case "any": {
+      const items = [];
+      for (const item of formula.items) {
+        const normalized = normalizeFormula(item);
+        if (normalized.kind === "false") {
+          continue;
+        }
+        if (normalized.kind === "true") {
+          return trueFormula();
+        }
+        if (normalized.kind === "any") {
+          items.push(...normalized.items);
+        } else {
+          items.push(normalized);
+        }
+      }
+      if (items.length === 0) {
+        return falseFormula();
+      }
+      if (items.length === 1) {
+        return items[0];
+      }
+      return { kind: "any", items };
+    }
+    case "not": {
+      const item = normalizeFormula(formula.item);
+      if (item.kind === "true") {
+        return falseFormula();
+      }
+      if (item.kind === "false") {
+        return trueFormula();
+      }
+      return { kind: "not", item };
+    }
+    default:
+      return formula;
+  }
+};
+var formulaOfExpression = (value) => {
+  const ast = astOf(value);
+  switch (ast.kind) {
+    case "literal":
+      if (ast.value === true) {
+        return trueFormula();
+      }
+      if (ast.value === false) {
+        return falseFormula();
+      }
+      return unknownTag("literal:non-boolean");
+    case "isNull": {
+      const key = columnKeyOfExpression(ast.value);
+      return key === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key });
+    }
+    case "isNotNull": {
+      const key = columnKeyOfExpression(ast.value);
+      return key === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key });
+    }
+    case "not":
+      return notFormula(formulaOfExpression(ast.value));
+    case "eq":
+      return formulaOfEq(ast.left, ast.right);
+    case "neq":
+      return formulaOfNeq(ast.left, ast.right);
+    case "isNotDistinctFrom":
+      return formulaOfIsNotDistinctFrom(ast.left, ast.right);
+    case "isDistinctFrom":
+      return notFormula(formulaOfIsNotDistinctFrom(ast.left, ast.right));
+    case "and":
+      return allFormula(ast.values.map((value2) => formulaOfExpression(value2)));
+    case "or":
+      return anyFormula(ast.values.map((value2) => formulaOfExpression(value2)));
+    case "in": {
+      const [left, ...rest] = ast.values;
+      return left === undefined ? falseFormula() : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
+    }
+    case "notIn": {
+      const [left, ...rest] = ast.values;
+      return left === undefined ? trueFormula() : allFormula(rest.map((value2) => formulaOfNeq(left, value2)));
+    }
+    case "between":
+      return combineFacts(ast.values.reduce((current, entry) => combineFacts(current, nonNullFactsOfExpression(entry)), undefined), unknownTag("variadic:between"));
+    case "lt":
+    case "lte":
+    case "gt":
+    case "gte":
+    case "like":
+    case "ilike":
+    case "contains":
+    case "containedBy":
+    case "overlaps":
+      return combineFacts(nonNullFactsOfExpression(ast.left), nonNullFactsOfExpression(ast.right));
+    default:
+      return unknownTag(`expr:${ast.kind}`);
+  }
+};
+var assumeFormulaTrue = (assumptions, formula) => assumptions.kind === "true" ? formula : andFormula(assumptions, formula);
+var assumeFormulaFalse = (assumptions, formula) => assumptions.kind === "true" ? notFormula(formula) : andFormula(assumptions, notFormula(formula));
+var contradictsFormula = (assumptions, formula) => analyzeFormula(andFormula(assumptions, formula)).contradiction;
+var impliesFormula = (assumptions, formula) => analyzeFormula(andFormula(assumptions, notFormula(formula))).contradiction;
+var guaranteedNonNullKeys = (assumptions) => analyzeFormula(assumptions).nonNullKeys;
+var guaranteedNullKeys = (assumptions) => analyzeFormula(assumptions).nullKeys;
+var guaranteedSourceNames = (assumptions) => analyzeFormula(assumptions).sourceNames;
+
 // src/internal/query.ts
 var ExpressionProto = {
   pipe() {
@@ -52668,7 +53436,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
     required: undefined,
     availableNames: undefined,
     grouped: undefined,
-    assumptions: undefined,
+    assumptions: _assumptions ?? trueFormula(),
     capabilities: undefined,
     statement: _statement ?? "select",
     target: _target ?? undefined,
@@ -52708,6 +53476,119 @@ var extractSingleSelectedExpressionRuntime = (selection) => {
 };
 var currentRequiredList = (required) => Array.isArray(required) ? [...required] : required === undefined ? [] : [required];
 
+// src/internal/implication-runtime.ts
+var presentFormulaOfSource = (source) => source._presentFormula ?? trueFormula();
+var collectPresenceWitnesses = (selection, output) => {
+  if (typeof selection !== "object" || selection === null) {
+    return;
+  }
+  if (TypeId in selection && TypeId2 in selection) {
+    const expression = selection;
+    const ast = expression[TypeId2];
+    if (ast.kind === "column" && expression[TypeId].nullability === "never") {
+      output.add(`${ast.tableName}.${ast.columnName}`);
+    }
+    return;
+  }
+  for (const value of Object.values(selection)) {
+    collectPresenceWitnesses(value, output);
+  }
+};
+var presenceWitnessesOfSourceLike = (source) => {
+  const output = new Set;
+  if (typeof source !== "object" || source === null) {
+    return [];
+  }
+  if (TypeId4 in source) {
+    collectPresenceWitnesses(source[TypeId3].selection, output);
+    return [...output];
+  }
+  if ("columns" in source) {
+    collectPresenceWitnesses(source.columns, output);
+  }
+  return [...output];
+};
+var directAbsentSourceNames = (available, assumptions) => {
+  const nullKeys = guaranteedNullKeys(assumptions);
+  const absent = new Set;
+  for (const [name2, source] of Object.entries(available)) {
+    if (source._presenceWitnesses?.some((key) => nullKeys.has(key))) {
+      absent.add(name2);
+      continue;
+    }
+    if (contradictsFormula(assumptions, presentFormulaOfSource(source))) {
+      absent.add(name2);
+    }
+  }
+  return absent;
+};
+var propagateAbsentSourceNames = (available, seed) => {
+  const absent = new Set(seed);
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [name2, source] of Object.entries(available)) {
+      if (absent.has(name2)) {
+        continue;
+      }
+      const required = guaranteedSourceNames(presentFormulaOfSource(source));
+      if (Array.from(required).some((dependency) => absent.has(dependency))) {
+        absent.add(name2);
+        changed = true;
+      }
+    }
+  }
+  return absent;
+};
+var resolveImplicationScope = (available, initialAssumptions) => {
+  let assumptions = initialAssumptions;
+  const required = new Set(Object.entries(available).filter(([, source]) => source.mode === "required").map(([name2]) => name2));
+  const appliedRequired = new Set;
+  let absent = new Set;
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const name2 of guaranteedSourceNames(assumptions)) {
+      if (!required.has(name2)) {
+        required.add(name2);
+        changed = true;
+      }
+    }
+    for (const name2 of required) {
+      if (absent.has(name2) || appliedRequired.has(name2)) {
+        continue;
+      }
+      const source = available[name2];
+      if (source === undefined) {
+        continue;
+      }
+      assumptions = assumeFormulaTrue(assumptions, presentFormulaOfSource(source));
+      appliedRequired.add(name2);
+      changed = true;
+    }
+    const nextAbsent = propagateAbsentSourceNames(available, directAbsentSourceNames(available, assumptions));
+    if (nextAbsent.size !== absent.size || Array.from(nextAbsent).some((name2) => !absent.has(name2))) {
+      absent = nextAbsent;
+      changed = true;
+    }
+  }
+  for (const name2 of absent) {
+    required.delete(name2);
+  }
+  const sourceModes = new Map;
+  for (const [name2, source] of Object.entries(available)) {
+    sourceModes.set(name2, required.has(name2) ? "required" : source.mode);
+  }
+  return {
+    assumptions,
+    nonNullKeys: guaranteedNonNullKeys(assumptions),
+    nullKeys: guaranteedNullKeys(assumptions),
+    requiredSourceNames: required,
+    absentSourceNames: absent,
+    sourceModes
+  };
+};
+
 // src/internal/json/path.ts
 var SegmentTypeId = Symbol.for("effect-qb/JsonPathSegment");
 var TypeId6 = Symbol.for("effect-qb/JsonPath");
@@ -52719,7 +53600,7 @@ var key = (value) => makeSegment({
   kind: "key",
   key: value
 });
-var index2 = (value) => makeSegment({
+var index3 = (value) => makeSegment({
   [SegmentTypeId]: {
     kind: "index"
   },
@@ -52839,7 +53720,7 @@ var isExpression = (value) => typeof value === "object" && value !== null && (Ty
 var projectionAliasOf = (expression) => (TypeId7 in expression) ? expression[TypeId7].alias : undefined;
 var pathKeyOf = (path2) => JSON.stringify(path2);
 var formatProjectionPath = (path2) => path2.join(".");
-var isPrefixPath = (left, right) => left.length < right.length && left.every((segment, index3) => segment === right[index3]);
+var isPrefixPath = (left, right) => left.length < right.length && left.every((segment, index4) => segment === right[index4]);
 var flattenSelection = (selection, path2 = []) => {
   const fields2 = [];
   for (const [key2, value] of Object.entries(selection)) {
@@ -52870,9 +53751,9 @@ var validateProjections = (projections) => {
     }
     pathKeys.add(pathKey);
   }
-  for (let index3 = 0;index3 < projections.length; index3++) {
-    const current = projections[index3];
-    for (let compareIndex = index3 + 1;compareIndex < projections.length; compareIndex++) {
+  for (let index4 = 0;index4 < projections.length; index4++) {
+    const current = projections[index4];
+    for (let compareIndex = index4 + 1;compareIndex < projections.length; compareIndex++) {
       const other = projections[compareIndex];
       if (isPrefixPath(current.path, other.path) || isPrefixPath(other.path, current.path)) {
         throw new Error(`Conflicting projection paths: ${formatProjectionPath(current.path)} conflicts with ${formatProjectionPath(other.path)}`);
@@ -52889,8 +53770,8 @@ var DerivedProto = {
 };
 var setPath = (target, path2, value) => {
   let current = target;
-  for (let index3 = 0;index3 < path2.length - 1; index3++) {
-    const segment = path2[index3];
+  for (let index4 = 0;index4 < path2.length - 1; index4++) {
+    const segment = path2[index4];
     const existing = current[segment];
     if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
       current = existing;
@@ -52977,8 +53858,17 @@ var makeLateralSource = (plan, alias2) => {
   return lateral;
 };
 
-// src/internal/query-factory.ts
-function makeDialectQuery(profile) {
+// src/internal/mysql-query.ts
+var mysqlQuery = (() => {
+  const profile = {
+    dialect: "mysql",
+    textDb: { dialect: "mysql", kind: "text" },
+    numericDb: { dialect: "mysql", kind: "double" },
+    boolDb: { dialect: "mysql", kind: "boolean" },
+    timestampDb: { dialect: "mysql", kind: "timestamp" },
+    nullDb: { dialect: "mysql", kind: "null" },
+    type: mysqlDatatypes
+  };
   const ValuesInputProto = {
     pipe() {
       return pipeArguments5(this, arguments);
@@ -52988,7 +53878,7 @@ function makeDialectQuery(profile) {
     if (value === null || value instanceof Date) {
       return;
     }
-    return Schema4.Literal(value);
+    return Schema5.Literal(value);
   };
   const literal = (value) => makeExpression({
     runtime: undefined,
@@ -53004,6 +53894,20 @@ function makeDialectQuery(profile) {
     kind: "literal",
     value
   });
+  const column = (name2, dbType, nullable3 = false) => makeExpression({
+    runtime: undefined,
+    dbType,
+    nullability: nullable3 ? "maybe" : "never",
+    dialect: profile.dialect,
+    aggregation: "scalar",
+    source: undefined,
+    sourceNullability: "resolved",
+    dependencies: {}
+  }, {
+    kind: "column",
+    tableName: "",
+    columnName: name2
+  });
   const toDialectExpression = (value) => {
     if (value !== null && typeof value === "object" && TypeId in value) {
       return value;
@@ -53012,6 +53916,53 @@ function makeDialectQuery(profile) {
   };
   const toDialectStringExpression = (value) => typeof value === "string" ? literal(value) : value;
   const toDialectNumericExpression = (value) => typeof value === "number" ? literal(value) : value;
+  const flattenVariadicBooleanExpressions = (kind, values2) => {
+    const flattened = [];
+    for (const value of values2) {
+      const ast = value[TypeId2];
+      if (ast.kind === kind) {
+        flattened.push(...ast.values);
+      } else {
+        flattened.push(value);
+      }
+    }
+    return flattened;
+  };
+  const makeVariadicBooleanExpression = (kind, values2) => {
+    const expressions = flattenVariadicBooleanExpressions(kind, values2);
+    const expression = makeExpression({
+      runtime: true,
+      dbType: profile.boolDb,
+      nullability: mergeNullabilityManyRuntime(expressions),
+      dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+      aggregation: mergeAggregationManyRuntime(expressions),
+      source: mergeManySources(expressions),
+      sourceNullability: "propagate",
+      dependencies: mergeManyDependencies(expressions)
+    }, {
+      kind,
+      values: expressions
+    });
+    Object.defineProperty(expression, "pipe", {
+      configurable: true,
+      writable: true,
+      value() {
+        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));
+          return makeVariadicBooleanExpression(kind, [...expressions, ...appended]);
+        }
+        if (operations.every((operation) => typeof operation === "function")) {
+          return pipeArguments5(this, arguments);
+        }
+        throw new TypeError(`Cannot mix query expressions and pipe functions inside ${kind}(...).pipe(...)`);
+      }
+    });
+    return expression;
+  };
   const extractRequiredFromDialectInputRuntime = (value) => {
     const expression = toDialectExpression(value);
     return Object.keys(expression[TypeId].dependencies);
@@ -53098,6 +54049,22 @@ function makeDialectQuery(profile) {
     const [left, right] = args;
     return buildBinaryPredicate(left, right, "ilike");
   };
+  const regexMatch = (...args) => {
+    const [left, right] = args;
+    return buildBinaryPredicate(left, right, "regexMatch");
+  };
+  const regexIMatch = (...args) => {
+    const [left, right] = args;
+    return buildBinaryPredicate(left, right, "regexIMatch");
+  };
+  const regexNotMatch = (...args) => {
+    const [left, right] = args;
+    return buildBinaryPredicate(left, right, "regexNotMatch");
+  };
+  const regexNotIMatch = (...args) => {
+    const [left, right] = args;
+    return buildBinaryPredicate(left, right, "regexNotIMatch");
+  };
   const isDistinctFrom = (...args) => {
     const [left, right] = args;
     return buildBinaryPredicate(left, right, "isDistinctFrom", "never", "resolved");
@@ -53188,7 +54155,7 @@ function makeDialectQuery(profile) {
       target
     });
   };
-  const array = (element) => ({
+  const array2 = (element) => ({
     dialect: profile.dialect,
     kind: `${element.kind}[]`,
     element
@@ -53223,23 +54190,28 @@ function makeDialectQuery(profile) {
     kind,
     variant: "set"
   });
+  const custom3 = (kind) => ({
+    dialect: profile.dialect,
+    kind
+  });
   const type = {
     ...profile.type,
-    array,
+    array: array2,
     range,
     multirange,
     record,
     domain,
     enum: enum_,
-    set
+    set,
+    custom: custom3
   };
   const makeJsonDb = (kind) => ({
     dialect: profile.dialect,
     kind,
-    variant: "json"
+    variant: kind === "jsonb" ? "jsonb" : "json"
   });
   const jsonDb = makeJsonDb("json");
-  const jsonbDb = makeJsonDb(profile.dialect === "postgres" ? "jsonb" : "json");
+  const jsonbDb = makeJsonDb("json");
   const isExpressionValue = (value) => value !== null && typeof value === "object" && (TypeId in value);
   const isJsonExpressionValue = (value) => isExpressionValue(value) && (() => {
     const dbType = value[TypeId].dbType;
@@ -53259,6 +54231,8 @@ function makeDialectQuery(profile) {
     sourceNullability: state.sourceNullability ?? "propagate",
     dependencies: mergeManyDependencies(expressions)
   }, ast);
+  const jsonDbTypeOf = (base) => base[TypeId].dbType;
+  const resolveJsonMergeDbType = (...values2) => values2.some((value) => value[TypeId].dbType.kind === "jsonb") ? jsonbDb : jsonDb;
   const makeJsonLiteralExpression = (value, dbType = jsonDb) => makeExpression({
     runtime: value,
     dbType,
@@ -53296,7 +54270,7 @@ function makeDialectQuery(profile) {
     const kind = isJsonPathValue(target) ? isExactJsonPathValue(segments) ? "jsonPath" : "jsonTraverse" : isExactJsonSegmentValue(target) ? "jsonGet" : "jsonAccess";
     return buildJsonNodeExpression([base], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType: jsonDbTypeOf(base),
       nullability: undefined
     }, {
       kind,
@@ -53321,7 +54295,7 @@ function makeDialectQuery(profile) {
     const segments = normalizeJsonPathInput(target);
     return buildJsonNodeExpression([base], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType: jsonDbTypeOf(base),
       nullability: undefined
     }, {
       kind: isJsonPathValue(target) || segments.length > 1 ? "jsonTraverse" : "jsonAccess",
@@ -53333,7 +54307,7 @@ function makeDialectQuery(profile) {
     const segments = normalizeJsonPathInput(target);
     return buildJsonNodeExpression([base], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType: jsonDbTypeOf(base),
       nullability: undefined
     }, {
       kind: "jsonTraverse",
@@ -53401,7 +54375,7 @@ function makeDialectQuery(profile) {
     const segments = normalizeJsonPathInput(target);
     return buildJsonNodeExpression([base], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType: jsonDbTypeOf(base),
       nullability: undefined
     }, {
       kind: isJsonPathValue(target) ? "jsonDeletePath" : "jsonDelete",
@@ -53413,7 +54387,7 @@ function makeDialectQuery(profile) {
     const segments = normalizeJsonPathInput(target);
     return buildJsonNodeExpression([base], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType: jsonDbTypeOf(base),
       nullability: undefined
     }, {
       kind: "jsonRemove",
@@ -53426,7 +54400,7 @@ function makeDialectQuery(profile) {
     const newValue = toJsonValueExpression(next);
     return buildJsonNodeExpression([base, newValue], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType: jsonDbTypeOf(base),
       nullability: undefined
     }, {
       kind: "jsonSet",
@@ -53442,7 +54416,7 @@ function makeDialectQuery(profile) {
     const insertAfter = options2.insertAfter ?? false;
     return buildJsonNodeExpression([base, insert2], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType: jsonDbTypeOf(base),
       nullability: undefined
     }, {
       kind: "jsonInsert",
@@ -53452,12 +54426,12 @@ function makeDialectQuery(profile) {
       insertAfter
     });
   };
-  const jsonConcat = (left, right) => {
+  const jsonConcatAs = (dbType) => (left, right) => {
     const leftExpression = toJsonValueExpression(left);
     const rightExpression = toJsonValueExpression(right);
     return buildJsonNodeExpression([leftExpression, rightExpression], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType,
       nullability: "maybe"
     }, {
       kind: "jsonConcat",
@@ -53465,12 +54439,12 @@ function makeDialectQuery(profile) {
       right: rightExpression
     });
   };
-  const jsonMerge = (left, right) => {
+  const jsonMergeAs = (dbType) => (left, right) => {
     const leftExpression = toJsonValueExpression(left);
     const rightExpression = toJsonValueExpression(right);
     return buildJsonNodeExpression([leftExpression, rightExpression], {
       runtime: undefined,
-      dbType: jsonDb,
+      dbType,
       nullability: "maybe"
     }, {
       kind: "jsonMerge",
@@ -53478,6 +54452,8 @@ function makeDialectQuery(profile) {
       right: rightExpression
     });
   };
+  const jsonConcat = jsonConcatAs(resolveJsonMergeDbType());
+  const jsonMerge = jsonMergeAs(resolveJsonMergeDbType());
   const jsonKeyExists = (base, key2) => buildJsonNodeExpression([base], {
     runtime: true,
     dbType: profile.boolDb,
@@ -53488,14 +54464,14 @@ function makeDialectQuery(profile) {
     base,
     keys: [key2]
   });
-  const jsonBuildObject = (shape) => {
+  const jsonBuildObjectAs = (dbType) => (shape) => {
     const entries = Object.entries(shape).map(([key2, value]) => ({
       key: key2,
       value: toJsonValueExpression(value)
     }));
     return buildJsonNodeExpression(entries.map((entry) => entry.value), {
       runtime: {},
-      dbType: jsonDb,
+      dbType,
       nullability: "never",
       sourceNullability: "resolved"
     }, {
@@ -53503,11 +54479,11 @@ function makeDialectQuery(profile) {
       entries
     });
   };
-  const jsonBuildArray = (...values2) => {
+  const jsonBuildArrayAs = (dbType) => (...values2) => {
     const expressions = values2.map((value) => toJsonValueExpression(value));
     return buildJsonNodeExpression(expressions, {
       runtime: [],
-      dbType: jsonDb,
+      dbType,
       nullability: "never",
       sourceNullability: "resolved"
     }, {
@@ -53515,6 +54491,10 @@ function makeDialectQuery(profile) {
       values: expressions
     });
   };
+  const jsonBuildObject = jsonBuildObjectAs(jsonDb);
+  const jsonBuildArray = jsonBuildArrayAs(jsonDb);
+  const jsonbBuildObject = jsonBuildObjectAs(jsonbDb);
+  const jsonbBuildArray = jsonBuildArrayAs(jsonbDb);
   const jsonToJson = (value) => toJsonValueExpression(value, "jsonToJson", jsonDb);
   const jsonToJsonb = (value) => toJsonValueExpression(value, "jsonToJsonb", jsonbDb);
   const jsonTypeOf = (base) => buildJsonNodeExpression([base], {
@@ -53568,7 +54548,7 @@ function makeDialectQuery(profile) {
   };
   const jsonStripNulls = (base) => buildJsonNodeExpression([base], {
     runtime: undefined,
-    dbType: jsonDb,
+    dbType: jsonDbTypeOf(base),
     nullability: undefined
   }, {
     kind: "jsonStripNulls",
@@ -53601,7 +54581,7 @@ function makeDialectQuery(profile) {
   };
   const json3 = {
     key,
-    index: index2,
+    index: index3,
     wildcard,
     slice,
     descend,
@@ -53635,38 +54615,43 @@ function makeDialectQuery(profile) {
     pathExists: jsonPathExists,
     pathMatch: jsonPathMatch
   };
-  const and = (...values2) => {
-    const expressions = values2.map((value) => toDialectExpression(value));
-    return makeExpression({
-      runtime: true,
-      dbType: profile.boolDb,
-      nullability: mergeNullabilityManyRuntime(expressions),
-      dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
-      aggregation: mergeAggregationManyRuntime(expressions),
-      source: mergeManySources(expressions),
-      sourceNullability: "propagate",
-      dependencies: mergeManyDependencies(expressions)
-    }, {
-      kind: "and",
-      values: expressions
-    });
-  };
-  const or = (...values2) => {
-    const expressions = values2.map((value) => toDialectExpression(value));
-    return makeExpression({
-      runtime: true,
-      dbType: profile.boolDb,
-      nullability: mergeNullabilityManyRuntime(expressions),
-      dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
-      aggregation: mergeAggregationManyRuntime(expressions),
-      source: mergeManySources(expressions),
-      sourceNullability: "propagate",
-      dependencies: mergeManyDependencies(expressions)
-    }, {
-      kind: "or",
-      values: expressions
-    });
+  const jsonb2 = {
+    key,
+    index: index3,
+    wildcard,
+    slice,
+    descend,
+    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 = (...values2) => makeVariadicBooleanExpression("and", values2.map((value) => toDialectExpression(value)));
+  const or = (...values2) => makeVariadicBooleanExpression("or", values2.map((value) => toDialectExpression(value)));
   const not = (value) => {
     const expression = toDialectExpression(value);
     return makeExpression({
@@ -53733,7 +54718,7 @@ function makeDialectQuery(profile) {
     });
   };
   const exists = (plan) => {
-    const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name) => [name, true]));
+    const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name2) => [name2, true]));
     return makeExpression({
       runtime: true,
       dbType: profile.boolDb,
@@ -53749,7 +54734,7 @@ function makeDialectQuery(profile) {
     });
   };
   const scalar = (plan) => {
-    const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name) => [name, true]));
+    const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name2) => [name2, true]));
     const expression = extractSingleSelectedExpressionRuntime(plan[TypeId3].selection);
     return makeExpression({
       runtime: undefined,
@@ -53767,7 +54752,7 @@ function makeDialectQuery(profile) {
   };
   const inSubquery = (left, plan) => {
     const leftExpression = toDialectExpression(left);
-    const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name) => [name, true]));
+    const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name2) => [name2, true]));
     return makeExpression({
       runtime: true,
       dbType: profile.boolDb,
@@ -53785,7 +54770,7 @@ function makeDialectQuery(profile) {
   };
   const quantifiedComparison = (left, plan, operator, quantifier) => {
     const leftExpression = toDialectExpression(left);
-    const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name) => [name, true]));
+    const dependencies = Object.fromEntries(currentRequiredList(plan[TypeId3].required).map((name2) => [name2, true]));
     return makeExpression({
       runtime: true,
       dbType: profile.boolDb,
@@ -53885,6 +54870,51 @@ function makeDialectQuery(profile) {
       values: expressions
     });
   };
+  const call = (name2, ...args) => {
+    const expressions = args.map((value) => toDialectExpression(value));
+    return makeExpression({
+      runtime: undefined,
+      dbType: profile.textDb,
+      nullability: "maybe",
+      dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
+      aggregation: mergeAggregationManyRuntime(expressions),
+      source: mergeManySources(expressions),
+      sourceNullability: "resolved",
+      dependencies: mergeManyDependencies(expressions)
+    }, {
+      kind: "function",
+      name: name2,
+      args: expressions
+    });
+  };
+  const uuidGenerateV4 = () => makeExpression({
+    runtime: undefined,
+    dbType: { dialect: "postgres", kind: "uuid" },
+    nullability: "never",
+    dialect: profile.dialect,
+    aggregation: "scalar",
+    source: undefined,
+    sourceNullability: "resolved",
+    dependencies: {}
+  }, {
+    kind: "function",
+    name: "uuid_generate_v4",
+    args: []
+  });
+  const nextVal = (value) => makeExpression({
+    runtime: undefined,
+    dbType: { dialect: "postgres", kind: "int8" },
+    nullability: "never",
+    dialect: profile.dialect,
+    aggregation: "scalar",
+    source: undefined,
+    sourceNullability: "resolved",
+    dependencies: {}
+  }, {
+    kind: "function",
+    name: "nextval",
+    args: [toDialectExpression(value)]
+  });
   const resolveCaseNullabilityRuntime = (values2) => {
     let sawNever = false;
     let sawMaybe = false;
@@ -53996,15 +55026,15 @@ function makeDialectQuery(profile) {
       columnName: ast.columnName
     });
   };
-  const toMutationValueExpression = (value, column) => {
+  const toMutationValueExpression = (value, column2) => {
     if (value !== null && typeof value === "object" && TypeId in value) {
       return value;
     }
     return makeExpression({
       runtime: value,
-      dbType: column[TypeId].dbType,
+      dbType: column2[TypeId].dbType,
       nullability: value === null ? "always" : "never",
-      dialect: column[TypeId].dialect,
+      dialect: column2[TypeId].dialect,
       aggregation: "scalar",
       source: undefined,
       sourceNullability: "propagate",
@@ -54132,7 +55162,7 @@ function makeDialectQuery(profile) {
     const columns = firstColumns;
     const normalizedRows = rows.map((row) => {
       const rowKeys = Object.keys(row);
-      if (rowKeys.length !== columns.length || columns.some((column) => !(column in row))) {
+      if (rowKeys.length !== columns.length || columns.some((column2) => !(column2 in row))) {
         throw new Error("All values(...) rows must project the same columns in the same shape");
       }
       const assignments = buildMutationAssignments(target, row);
@@ -54144,7 +55174,7 @@ function makeDialectQuery(profile) {
     return {
       columns,
       rows: normalizedRows,
-      required: required.filter((name, index3, list) => list.indexOf(name) === index3)
+      required: required.filter((name2, index4, list) => list.indexOf(name2) === index4)
     };
   };
   const normalizeInsertSelectColumns = (selection) => {
@@ -54255,7 +55285,7 @@ function makeDialectQuery(profile) {
     const columnNames = Object.keys(normalizedRows[0]);
     for (const row of normalizedRows) {
       const rowKeys = Object.keys(row);
-      if (rowKeys.length !== columnNames.length || !rowKeys.every((key2, index3) => key2 === columnNames[index3])) {
+      if (rowKeys.length !== columnNames.length || !rowKeys.every((key2, index4) => key2 === columnNames[index4])) {
         throw new Error("values(...) rows must project the same columns in the same order");
       }
     }
@@ -54372,7 +55402,7 @@ function makeDialectQuery(profile) {
     const predicateRequired = extractRequiredFromDialectInputRuntime(predicate);
     return makePlan({
       selection: current.selection,
-      required: [...currentRequiredList(current.required), ...predicateRequired].filter((name, index3, values2) => !(name in current.available) && values2.indexOf(name) === index3),
+      required: [...currentRequiredList(current.required), ...predicateRequired].filter((name2, index4, values2) => !(name2 in current.available) && values2.indexOf(name2) === index4),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -54381,7 +55411,7 @@ function makeDialectQuery(profile) {
         kind: "where",
         predicate: predicateExpression
       }]
-    }, undefined, currentQuery.capabilities, currentQuery.statement);
+    }, assumeFormulaTrue(currentQuery.assumptions, formulaOfExpression(predicateExpression)), currentQuery.capabilities, currentQuery.statement);
   };
   const from = (source) => (plan) => {
     const current = plan[TypeId3];
@@ -54395,6 +55425,7 @@ function makeDialectQuery(profile) {
     }
     const sourceLike = source;
     const { sourceName, sourceBaseName } = sourceDetails(sourceLike);
+    const presenceWitnesses = presenceWitnessesOfSourceLike(sourceLike);
     if (currentQuery.statement === "select") {
       const nextAst = {
         ...currentAst,
@@ -54407,12 +55438,14 @@ function makeDialectQuery(profile) {
       };
       return makePlan({
         selection: current.selection,
-        required: currentRequiredList(current.required).filter((name) => name !== sourceName),
+        required: currentRequiredList(current.required).filter((name2) => name2 !== sourceName),
         available: {
           [sourceName]: {
             name: sourceName,
             mode: "required",
-            baseName: sourceBaseName
+            baseName: sourceBaseName,
+            _presentFormula: trueFormula(),
+            _presenceWitnesses: presenceWitnesses
           }
         },
         dialect: current.dialect
@@ -54424,7 +55457,9 @@ function makeDialectQuery(profile) {
         [sourceName]: {
           name: sourceName,
           mode: "required",
-          baseName: sourceBaseName
+          baseName: sourceBaseName,
+          _presentFormula: trueFormula(),
+          _presenceWitnesses: presenceWitnesses
         }
       };
       const nextAst = {
@@ -54441,7 +55476,7 @@ function makeDialectQuery(profile) {
       };
       return makePlan({
         selection: current.selection,
-        required: currentRequiredList(current.required).filter((name) => !(name in nextAvailable)),
+        required: currentRequiredList(current.required).filter((name2) => !(name2 in nextAvailable)),
         available: nextAvailable,
         dialect: current.dialect
       }, nextAst, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
@@ -54456,7 +55491,7 @@ function makeDialectQuery(profile) {
     const predicateRequired = extractRequiredFromDialectInputRuntime(predicate);
     return makePlan({
       selection: current.selection,
-      required: [...currentRequiredList(current.required), ...predicateRequired].filter((name, index3, values2) => !(name in current.available) && values2.indexOf(name) === index3),
+      required: [...currentRequiredList(current.required), ...predicateRequired].filter((name2, index4, values2) => !(name2 in current.available) && values2.indexOf(name2) === index4),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -54465,7 +55500,7 @@ function makeDialectQuery(profile) {
         kind: "having",
         predicate: predicateExpression
       }]
-    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+    }, assumeFormulaTrue(currentQuery.assumptions, formulaOfExpression(predicateExpression)), currentQuery.capabilities, currentQuery.statement);
   };
   const innerJoin = (table, on) => join("inner", table, on);
   const leftJoin = (table, on) => join("left", table, on);
@@ -54476,16 +55511,19 @@ function makeDialectQuery(profile) {
     const currentAst = getAst(plan);
     const currentQuery = getQueryState(plan);
     const { sourceName, sourceBaseName } = sourceDetails(table);
+    const presenceWitnesses = presenceWitnessesOfSourceLike(table);
     const nextAvailable = Object.assign({}, current.available, {
       [sourceName]: {
         name: sourceName,
         mode: "required",
-        baseName: sourceBaseName
+        baseName: sourceBaseName,
+        _presentFormula: trueFormula(),
+        _presenceWitnesses: presenceWitnesses
       }
     });
     return makePlan({
       selection: current.selection,
-      required: currentRequiredList(current.required).filter((name) => !(name in nextAvailable)),
+      required: currentRequiredList(current.required).filter((name2) => !(name2 in nextAvailable)),
       available: nextAvailable,
       dialect: current.dialect
     }, {
@@ -54503,23 +55541,29 @@ function makeDialectQuery(profile) {
     const currentAst = getAst(plan);
     const currentQuery = getQueryState(plan);
     const onExpression = toDialectExpression(on);
+    const onFormula = formulaOfExpression(onExpression);
     const { sourceName, sourceBaseName } = sourceDetails(table);
-    const baseAvailable = kind === "right" || kind === "full" ? Object.fromEntries(Object.entries(current.available).map(([name, source]) => [name, {
+    const presenceWitnesses = presenceWitnessesOfSourceLike(table);
+    const baseAvailable = kind === "right" || kind === "full" ? Object.fromEntries(Object.entries(current.available).map(([name2, source]) => [name2, {
       name: source.name,
       mode: "optional",
-      baseName: source.baseName
+      baseName: source.baseName,
+      _presentFormula: source._presentFormula,
+      _presenceWitnesses: source._presenceWitnesses
     }])) : current.available;
     const nextAvailable = {
       ...baseAvailable,
       [sourceName]: {
         name: sourceName,
         mode: kind === "left" || kind === "full" ? "optional" : "required",
-        baseName: sourceBaseName
+        baseName: sourceBaseName,
+        _presentFormula: kind === "inner" || kind === "left" ? onFormula : trueFormula(),
+        _presenceWitnesses: presenceWitnesses
       }
     };
     return makePlan({
       selection: current.selection,
-      required: [...currentRequiredList(current.required), ...extractRequiredFromDialectInputRuntime(on)].filter((name, index3, values2) => !(name in nextAvailable) && values2.indexOf(name) === index3),
+      required: [...currentRequiredList(current.required), ...extractRequiredFromDialectInputRuntime(on)].filter((name2, index4, values2) => !(name2 in nextAvailable) && values2.indexOf(name2) === index4),
       available: nextAvailable,
       dialect: current.dialect
     }, {
@@ -54531,7 +55575,7 @@ function makeDialectQuery(profile) {
         source: table,
         on: onExpression
       }]
-    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+    }, kind === "inner" ? assumeFormulaTrue(currentQuery.assumptions, onFormula) : currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const orderBy = (value, direction = "asc") => (plan) => {
     const current = plan[TypeId3];
@@ -54541,7 +55585,7 @@ function makeDialectQuery(profile) {
     const required = extractRequiredFromDialectInputRuntime(value);
     return makePlan({
       selection: current.selection,
-      required: [...currentRequiredList(current.required), ...required].filter((name, index3, values2) => !(name in current.available) && values2.indexOf(name) === index3),
+      required: [...currentRequiredList(current.required), ...required].filter((name2, index4, values2) => !(name2 in current.available) && values2.indexOf(name2) === index4),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -54588,30 +55632,10 @@ function makeDialectQuery(profile) {
       distinct: true
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
-  const distinctOn = (...values2) => {
-    const expressions = values2.map((value) => toDialectExpression(value));
-    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"
-      };
-    }
-    return (plan) => {
-      const current = plan[TypeId3];
-      const currentAst = getAst(plan);
-      const currentQuery = getQueryState(plan);
-      return makePlan({
-        selection: current.selection,
-        required: current.required,
-        available: current.available,
-        dialect: current.dialect
-      }, {
-        ...currentAst,
-        distinct: true,
-        distinctOn: expressions
-      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
-    };
+  const distinctOn = {
+    __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"
   };
   const limit = (value) => (plan) => {
     const current = plan[TypeId3];
@@ -54621,7 +55645,7 @@ function makeDialectQuery(profile) {
     const required = extractRequiredFromDialectNumericInputRuntime(value);
     return makePlan({
       selection: current.selection,
-      required: [...currentRequiredList(current.required), ...required].filter((name, index3, values2) => !(name in current.available) && values2.indexOf(name) === index3),
+      required: [...currentRequiredList(current.required), ...required].filter((name2, index4, values2) => !(name2 in current.available) && values2.indexOf(name2) === index4),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -54637,7 +55661,7 @@ function makeDialectQuery(profile) {
     const required = extractRequiredFromDialectNumericInputRuntime(value);
     return makePlan({
       selection: current.selection,
-      required: [...currentRequiredList(current.required), ...required].filter((name, index3, values2) => !(name in current.available) && values2.indexOf(name) === index3),
+      required: [...currentRequiredList(current.required), ...required].filter((name2, index4, values2) => !(name2 in current.available) && values2.indexOf(name2) === index4),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -54649,10 +55673,10 @@ function makeDialectQuery(profile) {
     const current = plan[TypeId3];
     const currentAst = getAst(plan);
     const currentQuery = getQueryState(plan);
-    const required = [...values2.flatMap((value) => Object.keys(value[TypeId].dependencies))].filter((name, index3, list) => !(name in current.available) && list.indexOf(name) === index3);
+    const required = [...values2.flatMap((value) => Object.keys(value[TypeId].dependencies))].filter((name2, index4, list) => !(name2 in current.available) && list.indexOf(name2) === index4);
     return makePlan({
       selection: current.selection,
-      required: [...currentRequiredList(current.required), ...required].filter((name, index3, list) => !(name in current.available) && list.indexOf(name) === index3),
+      required: [...currentRequiredList(current.required), ...required].filter((name2, index4, list) => !(name2 in current.available) && list.indexOf(name2) === index4),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -54666,7 +55690,7 @@ function makeDialectQuery(profile) {
     const currentQuery = getQueryState(plan);
     return makePlan({
       selection,
-      required: [...currentRequiredList(current.required), ...extractRequiredRuntime(selection)].filter((name, index3, list) => !(name in current.available) && list.indexOf(name) === index3),
+      required: [...currentRequiredList(current.required), ...extractRequiredRuntime(selection)].filter((name2, index4, list) => !(name2 in current.available) && list.indexOf(name2) === index4),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -54681,7 +55705,7 @@ function makeDialectQuery(profile) {
     const insertState = values2 === undefined ? "missing" : "ready";
     return makePlan({
       selection: {},
-      required: required.filter((name, index3, list) => name !== sourceName && list.indexOf(name) === index3),
+      required: required.filter((name2, index4, list) => name2 !== sourceName && list.indexOf(name2) === index4),
       available: {
         [sourceName]: {
           name: sourceName,
@@ -54720,7 +55744,7 @@ function makeDialectQuery(profile) {
       const normalized = buildInsertValuesRows(target, valuesSource.rows);
       return makePlan({
         selection: current.selection,
-        required: normalized.required.filter((name) => name !== sourceName),
+        required: normalized.required.filter((name2) => name2 !== sourceName),
         available: current.available,
         dialect: current.dialect
       }, {
@@ -54756,7 +55780,7 @@ function makeDialectQuery(profile) {
     const columns = normalizeInsertSelectColumns(selection);
     return makePlan({
       selection: current.selection,
-      required: currentRequiredList(sourcePlan[TypeId3].required).filter((name) => name !== sourceName),
+      required: currentRequiredList(sourcePlan[TypeId3].required).filter((name2) => name2 !== sourceName),
       available: current.available,
       dialect: current.dialect
     }, {
@@ -54781,7 +55805,7 @@ function makeDialectQuery(profile) {
       ...currentRequiredList(current.required),
       ...updateAssignments.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies)),
       ...updateWhere ? Object.keys(updateWhere[TypeId].dependencies) : []
-    ].filter((name, index3, list) => !(name in current.available) && list.indexOf(name) === index3);
+    ].filter((name2, index4, list) => !(name2 in current.available) && list.indexOf(name2) === index4);
     return makePlan({
       selection: current.selection,
       required,
@@ -54803,7 +55827,7 @@ function makeDialectQuery(profile) {
     const primaryTarget = targets[0];
     const assignments = buildMutationAssignments(target, values2);
     const targetNames = new Set(targets.map((entry) => entry.tableName));
-    const required = assignments.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies)).filter((name, index3, list) => !targetNames.has(name) && list.indexOf(name) === index3);
+    const required = assignments.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies)).filter((name2, index4, list) => !targetNames.has(name2) && list.indexOf(name2) === index4);
     return makePlan({
       selection: {},
       required,
@@ -54832,7 +55856,7 @@ function makeDialectQuery(profile) {
     ];
     return makePlan({
       selection: {},
-      required: required.filter((name, index3, list) => name !== sourceName && list.indexOf(name) === index3),
+      required: required.filter((name2, index4, list) => name2 !== sourceName && list.indexOf(name2) === index4),
       available: {
         [sourceName]: {
           name: sourceName,
@@ -54934,7 +55958,7 @@ function makeDialectQuery(profile) {
       ...notMatchedAssignments.flatMap((entry) => Object.keys(entry.value[TypeId].dependencies)),
       ...matchedPredicate ? Object.keys(matchedPredicate[TypeId].dependencies) : [],
       ...notMatchedPredicate ? Object.keys(notMatchedPredicate[TypeId].dependencies) : []
-    ].filter((name, index3, values2) => name !== targetName && name !== usingName && values2.indexOf(name) === index3);
+    ].filter((name2, index4, values2) => name2 !== targetName && name2 !== usingName && values2.indexOf(name2) === index4);
     return makePlan({
       selection: {},
       required,
@@ -55043,7 +56067,7 @@ function makeDialectQuery(profile) {
     groupBy: [],
     orderBy: []
   }, undefined, "transaction", "rollback");
-  const savepoint = (name) => makePlan({
+  const savepoint = (name2) => makePlan({
     selection: {},
     required: [],
     available: {},
@@ -55053,7 +56077,7 @@ function makeDialectQuery(profile) {
     select: {},
     transaction: {
       kind: "savepoint",
-      name
+      name: name2
     },
     where: [],
     having: [],
@@ -55061,7 +56085,7 @@ function makeDialectQuery(profile) {
     groupBy: [],
     orderBy: []
   }, undefined, "transaction", "savepoint");
-  const rollbackTo = (name) => makePlan({
+  const rollbackTo = (name2) => makePlan({
     selection: {},
     required: [],
     available: {},
@@ -55071,7 +56095,7 @@ function makeDialectQuery(profile) {
     select: {},
     transaction: {
       kind: "rollbackTo",
-      name
+      name: name2
     },
     where: [],
     having: [],
@@ -55079,7 +56103,7 @@ function makeDialectQuery(profile) {
     groupBy: [],
     orderBy: []
   }, undefined, "transaction", "rollbackTo");
-  const releaseSavepoint = (name) => makePlan({
+  const releaseSavepoint = (name2) => makePlan({
     selection: {},
     required: [],
     available: {},
@@ -55089,7 +56113,7 @@ function makeDialectQuery(profile) {
     select: {},
     transaction: {
       kind: "releaseSavepoint",
-      name
+      name: name2
     },
     where: [],
     having: [],
@@ -55213,9 +56237,11 @@ function makeDialectQuery(profile) {
   };
   const api = {
     literal,
+    column,
     cast,
     type,
     json: json3,
+    jsonb: jsonb2,
     eq,
     neq,
     lt,
@@ -55228,6 +56254,10 @@ function makeDialectQuery(profile) {
     lower,
     like,
     ilike,
+    regexMatch,
+    regexIMatch,
+    regexNotMatch,
+    regexNotIMatch,
     and,
     or,
     not,
@@ -55236,6 +56266,9 @@ function makeDialectQuery(profile) {
     case: case_,
     match,
     coalesce,
+    call,
+    uuidGenerateV4,
+    nextVal,
     in: in_,
     notIn,
     between,
@@ -55307,21 +56340,10 @@ function makeDialectQuery(profile) {
     groupBy
   };
   return api;
-}
-
-// src/mysql/private/query.ts
-var mysqlQuery = makeDialectQuery({
-  dialect: "mysql",
-  textDb: { dialect: "mysql", kind: "text" },
-  numericDb: { dialect: "mysql", kind: "double" },
-  boolDb: { dialect: "mysql", kind: "boolean" },
-  timestampDb: { dialect: "mysql", kind: "timestamp" },
-  nullDb: { dialect: "mysql", kind: "null" },
-  type: mysqlDatatypes
-});
-
+})();
 // src/mysql/function/core.ts
 var coalesce = mysqlQuery.coalesce;
+var call = mysqlQuery.call;
 // src/mysql/function/string.ts
 var exports_string = {};
 __export(exports_string, {
@@ -55366,7 +56388,7 @@ __export(exports_temporal, {
   currentTime: () => currentTime,
   currentDate: () => currentDate
 });
-var makeTemporal = (name, dbType, runtimeSchema) => makeExpression({
+var makeTemporal = (name2, dbType, runtimeSchema) => makeExpression({
   runtime: undefined,
   dbType,
   runtimeSchema,
@@ -55378,7 +56400,7 @@ var makeTemporal = (name, dbType, runtimeSchema) => makeExpression({
   sourceNullability: "resolved"
 }, {
   kind: "function",
-  name,
+  name: name2,
   args: []
 });
 var currentDate = () => makeTemporal("current_date", { dialect: "mysql", kind: "date" }, LocalDateStringSchema);
@@ -55401,10 +56423,200 @@ import * as SqlClient3 from "@effect/sql/SqlClient";
 
 // src/internal/executor.ts
 import * as Effect from "effect/Effect";
-import * as Schema6 from "effect/Schema";
+import * as Schema7 from "effect/Schema";
 import * as SqlClient from "@effect/sql/SqlClient";
 
 // src/postgres/datatypes/spec.ts
+var postgresDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "timestamp",
+      "interval",
+      "binary",
+      "uuid",
+      "json",
+      "xml",
+      "bit",
+      "oid",
+      "identifier",
+      "network",
+      "spatial",
+      "textsearch",
+      "range",
+      "multirange",
+      "array",
+      "money",
+      "null"
+    ],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "text", "boolean", "date", "time", "timestamp", "interval", "uuid", "bit", "oid", "money"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "text", "numeric"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  timestamp: {
+    compareGroup: "timestamp",
+    castTargets: ["timestamp", "date", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  interval: {
+    compareGroup: "interval",
+    castTargets: ["interval", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  binary: {
+    compareGroup: "binary",
+    castTargets: ["binary", "text"],
+    traits: {}
+  },
+  uuid: {
+    compareGroup: "uuid",
+    castTargets: ["uuid", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  xml: {
+    compareGroup: "xml",
+    castTargets: ["xml", "text"],
+    traits: {}
+  },
+  bit: {
+    compareGroup: "bit",
+    castTargets: ["bit", "text", "numeric"],
+    traits: {}
+  },
+  oid: {
+    compareGroup: "oid",
+    castTargets: ["oid", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  identifier: {
+    compareGroup: "identifier",
+    castTargets: ["identifier", "text"],
+    traits: {}
+  },
+  network: {
+    compareGroup: "network",
+    castTargets: ["network", "text"],
+    traits: {}
+  },
+  spatial: {
+    compareGroup: "spatial",
+    castTargets: ["spatial", "text"],
+    traits: {}
+  },
+  textsearch: {
+    compareGroup: "textsearch",
+    castTargets: ["textsearch", "text"],
+    traits: {}
+  },
+  range: {
+    compareGroup: "range",
+    castTargets: ["range", "text"],
+    traits: {}
+  },
+  multirange: {
+    compareGroup: "multirange",
+    castTargets: ["multirange", "text"],
+    traits: {}
+  },
+  enum: {
+    compareGroup: "enum",
+    castTargets: ["enum", "text"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  record: {
+    compareGroup: "record",
+    castTargets: ["record", "text"],
+    traits: {}
+  },
+  array: {
+    compareGroup: "array",
+    castTargets: ["array", "text"],
+    traits: {}
+  },
+  money: {
+    compareGroup: "money",
+    castTargets: ["money", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "timestamp",
+      "interval",
+      "binary",
+      "uuid",
+      "json",
+      "xml",
+      "bit",
+      "oid",
+      "identifier",
+      "network",
+      "spatial",
+      "textsearch",
+      "range",
+      "multirange",
+      "array",
+      "money",
+      "null"
+    ],
+    traits: {}
+  }
+};
 var postgresDatatypeKinds = {
   text: { family: "text", runtime: "string" },
   varchar: { family: "text", runtime: "string" },
@@ -55784,7 +56996,7 @@ var normalizeDbValue = (dbType, value) => {
 };
 
 // src/internal/runtime-schema.ts
-import * as Schema5 from "effect/Schema";
+import * as Schema6 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
 var stripParameterizedKind2 = (kind) => {
@@ -55802,13 +57014,13 @@ var baseKind2 = (kind) => stripArrayKind2(stripParameterizedKind2(kind));
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
-      return Schema5.String;
+      return Schema6.String;
     case "number":
-      return Schema5.Number;
+      return Schema6.Number;
     case "bigintString":
       return BigIntStringSchema;
     case "boolean":
-      return Schema5.Boolean;
+      return Schema6.Boolean;
     case "json":
       return JsonValueSchema;
     case "localDate":
@@ -55826,16 +57038,16 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema5.Uint8ArrayFromSelf;
+      return Schema6.Uint8ArrayFromSelf;
     case "array":
-      return Schema5.Array(Schema5.Unknown);
+      return Schema6.Array(Schema6.Unknown);
     case "record":
-      return Schema5.Record({
-        key: Schema5.String,
-        value: Schema5.Unknown
+      return Schema6.Record({
+        key: Schema6.String,
+        value: Schema6.Unknown
       });
     case "null":
-      return Schema5.Null;
+      return Schema6.Null;
     case "unknown":
       return;
   }
@@ -55855,22 +57067,22 @@ var runtimeSchemaForDbType = (dbType) => {
     return runtimeSchemaForDbType(dbType.base);
   }
   if ("element" in dbType) {
-    return Schema5.Array(runtimeSchemaForDbType(dbType.element) ?? Schema5.Unknown);
+    return Schema6.Array(runtimeSchemaForDbType(dbType.element) ?? Schema6.Unknown);
   }
   if ("fields" in dbType) {
-    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema5.Unknown]));
-    return Schema5.Struct(fields2);
+    const fields2 = Object.fromEntries(Object.entries(dbType.fields).map(([key2, field]) => [key2, runtimeSchemaForDbType(field) ?? Schema6.Unknown]));
+    return Schema6.Struct(fields2);
   }
   if ("variant" in dbType && dbType.variant === "json") {
     return JsonValueSchema;
   }
   if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
-    return Schema5.String;
+    return Schema6.String;
   }
   const runtimeTag = runtimeTagOfBaseDbType2(dbType.dialect, dbType.kind);
   return runtimeTag === undefined ? undefined : runtimeSchemaForTag(runtimeTag);
 };
-var makeSchemaFromAst = (ast) => Schema5.make(ast);
+var makeSchemaFromAst = (ast) => Schema6.make(ast);
 var unionAst = (asts) => {
   if (asts.length === 0) {
     return;
@@ -55893,8 +57105,8 @@ var propertyAstOf = (ast, key2) => {
       if (property !== undefined) {
         return property.type;
       }
-      const index3 = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword");
-      return index3?.type;
+      const index4 = ast.indexSignatures.find((entry) => entry.parameter._tag === "StringKeyword");
+      return index4?.type;
     }
     case "Union": {
       const values = ast.types.flatMap((member) => {
@@ -55907,16 +57119,16 @@ var propertyAstOf = (ast, key2) => {
       return;
   }
 };
-var numberAstOf = (ast, index3) => {
+var numberAstOf = (ast, index4) => {
   switch (ast._tag) {
     case "Transformation":
-      return numberAstOf(SchemaAST.typeAST(ast), index3);
+      return numberAstOf(SchemaAST.typeAST(ast), index4);
     case "Refinement":
-      return numberAstOf(ast.from, index3);
+      return numberAstOf(ast.from, index4);
     case "Suspend":
-      return numberAstOf(ast.f(), index3);
+      return numberAstOf(ast.f(), index4);
     case "TupleType": {
-      const element = ast.elements[index3];
+      const element = ast.elements[index4];
       if (element !== undefined) {
         return element.type;
       }
@@ -55927,7 +57139,7 @@ var numberAstOf = (ast, index3) => {
     }
     case "Union": {
       const values = ast.types.flatMap((member) => {
-        const next = numberAstOf(member, index3);
+        const next = numberAstOf(member, index4);
         return next === undefined ? [] : [next];
       });
       return unionAst(values);
@@ -55968,7 +57180,7 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema5.Union(...resolved);
+  return Schema6.Union(...resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
@@ -56001,12 +57213,39 @@ var jsonCompatibleSchema = (schema4) => {
   const ast = SchemaAST.typeAST(schema4.ast);
   return isJsonCompatibleAst(ast) ? schema4 : JsonValueSchema;
 };
-var buildStructSchema = (entries) => {
-  const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value) ?? JsonValueSchema]));
-  return Schema5.Struct(fields2);
+var buildStructSchema = (entries, context) => {
+  const fields2 = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
+  return Schema6.Struct(fields2);
+};
+var buildTupleSchema = (values, context) => Schema6.Tuple(...values.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var deriveCaseSchema = (ast, context) => {
+  if (context === undefined) {
+    return unionSchemas([
+      ...ast.branches.map((branch) => expressionRuntimeSchema(branch.then)),
+      expressionRuntimeSchema(ast.else)
+    ]);
+  }
+  const schemas = [];
+  let elseAssumptions = context.assumptions;
+  for (const branch of ast.branches) {
+    const whenFormula = formulaOfExpression(branch.when);
+    if (contradictsFormula(elseAssumptions, whenFormula)) {
+      continue;
+    }
+    const branchContext = { assumptions: assumeFormulaTrue(elseAssumptions, whenFormula) };
+    const branchSchema = expressionRuntimeSchema(branch.then, branchContext);
+    if (branchSchema !== undefined) {
+      schemas.push(branchSchema);
+    }
+    if (impliesFormula(elseAssumptions, whenFormula)) {
+      return unionSchemas(schemas);
+    }
+    elseAssumptions = assumeFormulaFalse(elseAssumptions, whenFormula);
+  }
+  const elseSchema = expressionRuntimeSchema(ast.else, { assumptions: elseAssumptions });
+  return unionSchemas(elseSchema === undefined ? schemas : [...schemas, elseSchema]);
 };
-var buildTupleSchema = (values) => Schema5.Tuple(...values.map((value) => expressionRuntimeSchema(value) ?? JsonValueSchema));
-var deriveRuntimeSchema = (expression) => {
+var deriveRuntimeSchema = (expression, context) => {
   const state = expression[TypeId];
   if (state.runtimeSchema !== undefined) {
     return state.runtimeSchema;
@@ -56018,10 +57257,10 @@ var deriveRuntimeSchema = (expression) => {
       return state.runtimeSchema;
     case "literal":
       if (ast.value === null) {
-        return Schema5.Null;
+        return Schema6.Null;
       }
       if (typeof ast.value === "string" || typeof ast.value === "number" || typeof ast.value === "boolean") {
-        return Schema5.Literal(ast.value);
+        return Schema6.Literal(ast.value);
       }
       return runtimeSchemaForDbType(state.dbType);
     case "cast":
@@ -56057,7 +57296,7 @@ var deriveRuntimeSchema = (expression) => {
     case "jsonHasAllKeys":
     case "jsonPathExists":
     case "jsonPathMatch":
-      return Schema5.Boolean;
+      return Schema6.Boolean;
     case "upper":
     case "lower":
     case "concat":
@@ -56066,31 +57305,28 @@ var deriveRuntimeSchema = (expression) => {
     case "jsonAccessText":
     case "jsonTraverseText":
     case "jsonTypeOf":
-      return Schema5.String;
+      return Schema6.String;
     case "count":
     case "jsonLength":
-      return Schema5.Number;
+      return Schema6.Number;
     case "max":
     case "min":
-      return expressionRuntimeSchema(ast.value);
+      return expressionRuntimeSchema(ast.value, context);
     case "case":
-      return unionSchemas([
-        ...ast.branches.map((branch) => expressionRuntimeSchema(branch.then)),
-        expressionRuntimeSchema(ast.else)
-      ]);
+      return deriveCaseSchema(ast, context);
     case "coalesce":
-      return unionSchemas(ast.values.map(expressionRuntimeSchema));
+      return unionSchemas(ast.values.map((value) => expressionRuntimeSchema(value, context)));
     case "scalarSubquery": {
       const selection = firstSelectedExpression(ast.plan);
-      return selection === undefined ? undefined : expressionRuntimeSchema(selection);
+      return selection === undefined ? undefined : expressionRuntimeSchema(selection, context);
     }
     case "window":
-      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value) : Schema5.Number;
+      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : Schema6.Number;
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
     case "jsonTraverse": {
-      const baseSchema = expressionRuntimeSchema(ast.base);
+      const baseSchema = expressionRuntimeSchema(ast.base, context);
       const segments = ast.segments;
       if (baseSchema === undefined || segments === undefined || !exactJsonSegments(segments)) {
         return JsonValueSchema;
@@ -56103,24 +57339,27 @@ var deriveRuntimeSchema = (expression) => {
     case "jsonRemove":
     case "jsonSet":
     case "jsonInsert":
-      return expressionRuntimeSchema(ast.base);
+      return expressionRuntimeSchema(ast.base, context);
     case "jsonStripNulls":
-      return expressionRuntimeSchema(ast.value);
+      return expressionRuntimeSchema(ast.value, context);
     case "jsonConcat":
     case "jsonMerge":
       return JsonValueSchema;
     case "jsonBuildObject":
-      return buildStructSchema(ast.entries ?? []);
+      return buildStructSchema(ast.entries ?? [], context);
     case "jsonBuildArray":
-      return buildTupleSchema(ast.values ?? []);
+      return buildTupleSchema(ast.values ?? [], context);
     case "jsonToJson":
     case "jsonToJsonb":
-      return jsonCompatibleSchema(expressionRuntimeSchema(ast.value));
+      return jsonCompatibleSchema(expressionRuntimeSchema(ast.value, context));
     case "jsonKeys":
-      return Schema5.Array(Schema5.String);
+      return Schema6.Array(Schema6.String);
   }
 };
-var expressionRuntimeSchema = (expression) => {
+var expressionRuntimeSchema = (expression, context) => {
+  if (context !== undefined) {
+    return deriveRuntimeSchema(expression, context) ?? runtimeSchemaForDbType(expression[TypeId].dbType);
+  }
   const cached = schemaCache.get(expression);
   if (cached !== undefined || schemaCache.has(expression)) {
     return cached;
@@ -56133,8 +57372,8 @@ var expressionRuntimeSchema = (expression) => {
 // src/internal/executor.ts
 var setPath2 = (target, path2, value) => {
   let current = target;
-  for (let index3 = 0;index3 < path2.length - 1; index3++) {
-    const key2 = path2[index3];
+  for (let index4 = 0;index4 < path2.length - 1; index4++) {
+    const key2 = path2[index4];
     const existing = current[key2];
     if (typeof existing === "object" && existing !== null && !Array.isArray(existing)) {
       current = existing;
@@ -56193,21 +57432,34 @@ var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, n
   stage,
   cause
 });
-var hasOptionalSourceDependency = (expression, available) => {
+var hasOptionalSourceDependency = (expression, scope) => {
   const state = expression[TypeId];
   if (state.sourceNullability === "resolved") {
     return false;
   }
-  return Object.keys(state.dependencies).some((sourceName) => available[sourceName]?.mode === "optional");
+  return Object.keys(state.dependencies).some((sourceName) => !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional");
 };
-var effectiveRuntimeNullability = (expression, available) => {
+var effectiveRuntimeNullability = (expression, scope) => {
   const nullability = expression[TypeId].nullability;
+  const ast = expression[TypeId2];
   if (nullability === "always") {
     return "always";
   }
-  return hasOptionalSourceDependency(expression, available) ? "maybe" : nullability;
+  if (ast.kind === "column") {
+    const key2 = `${ast.tableName}.${ast.columnName}`;
+    if (scope.absentSourceNames.has(ast.tableName) || scope.nullKeys.has(key2)) {
+      return "always";
+    }
+    if (scope.nonNullKeys.has(key2)) {
+      return "never";
+    }
+  }
+  if (expression[TypeId].sourceNullability !== "resolved" && Object.keys(expression[TypeId].dependencies).some((sourceName) => scope.absentSourceNames.has(sourceName))) {
+    return "always";
+  }
+  return hasOptionalSourceDependency(expression, scope) ? "maybe" : nullability;
 };
-var decodeProjectionValue = (rendered, projection, expression, raw, available, driverMode) => {
+var decodeProjectionValue = (rendered, projection, expression, raw, scope, driverMode) => {
   let normalized = raw;
   if (driverMode === "raw") {
     try {
@@ -56216,21 +57468,25 @@ var decodeProjectionValue = (rendered, projection, expression, raw, available, d
       throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause);
     }
   }
+  const nullability = effectiveRuntimeNullability(expression, scope);
   if (normalized === null) {
-    if (effectiveRuntimeNullability(expression, available) === "never") {
+    if (nullability === "never") {
       throw makeRowDecodeError(rendered, projection, expression, raw, "schema", new Error("Received null for a non-null projection"), normalized);
     }
     return null;
   }
-  const schema4 = expressionRuntimeSchema(expression);
+  if (nullability === "always") {
+    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", new Error("Received non-null for an always-null projection"), normalized);
+  }
+  const schema4 = expressionRuntimeSchema(expression, { assumptions: scope.assumptions });
   if (schema4 === undefined) {
     return normalized;
   }
-  if (Schema6.is(schema4)(normalized)) {
+  if (Schema7.is(schema4)(normalized)) {
     return normalized;
   }
   try {
-    return Schema6.decodeUnknownSync(schema4)(normalized);
+    return Schema7.decodeUnknownSync(schema4)(normalized);
   } catch (cause) {
     throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
   }
@@ -56239,7 +57495,7 @@ var decodeRows = (rendered, plan, rows, options2 = {}) => {
   const projections = flattenSelection(getAst(plan).select);
   const byAlias = new Map(projections.map((projection) => [projection.alias, projection.expression]));
   const driverMode = options2.driverMode ?? "raw";
-  const available = plan[TypeId3].available;
+  const scope = resolveImplicationScope(plan[TypeId3].available, getQueryState(plan).assumptions);
   return rows.map((row) => {
     const decoded = {};
     for (const projection of rendered.projections) {
@@ -56250,7 +57506,7 @@ var decodeRows = (rendered, plan, rows, options2 = {}) => {
       if (expression === undefined) {
         continue;
       }
-      setPath2(decoded, projection.path, decodeProjectionValue(rendered, projection, expression, row[projection.alias], available, driverMode));
+      setPath2(decoded, projection.path, decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode));
     }
     return decoded;
   });
@@ -56328,6 +57584,29 @@ var validateAggregationSelection = (selection, grouped) => {
   }
 };
 
+// src/internal/schema-expression.ts
+import { parse, toSql } from "pgsql-ast-parser";
+import { pipeArguments as pipeArguments6 } from "effect/Pipeable";
+var TypeId8 = Symbol.for("effect-qb/SchemaExpression");
+var SchemaExpressionProto = {
+  pipe() {
+    return pipeArguments6(this, arguments);
+  }
+};
+var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId8 in value);
+var fromAst = (ast) => {
+  const expression = Object.create(SchemaExpressionProto);
+  expression[TypeId8] = {
+    dialect: "postgres",
+    ast
+  };
+  return expression;
+};
+var parseExpression = (sql) => fromAst(parse(sql, "expr"));
+var toAst = (expression) => expression[TypeId8].ast;
+var render = (expression) => toSql.expr(expression[TypeId8].ast);
+var normalize2 = (expression) => parseExpression(render(expression));
+
 // src/internal/sql-expression-renderer.ts
 var renderDbType = (dialect, dbType) => {
   if (dialect.name === "mysql" && dbType.dialect === "mysql" && dbType.kind === "uuid") {
@@ -56357,43 +57636,43 @@ var renderCastType = (dialect, dbType) => {
       return dbType.kind;
   }
 };
+var renderDdlExpression = (expression, state, dialect) => isSchemaExpression(expression) ? render(expression) : renderExpression(expression, state, dialect);
 var renderColumnDefinition = (dialect, state, columnName, column) => {
   const clauses = [
     dialect.quoteIdentifier(columnName),
-    renderDbType(dialect, column.metadata.dbType)
+    column.metadata.ddlType ?? renderDbType(dialect, column.metadata.dbType)
   ];
-  if (column.metadata.generatedValue) {
-    clauses.push(`generated always as (${renderExpression(column.metadata.generatedValue, state, dialect)}) stored`);
+  if (column.metadata.identity) {
+    clauses.push(`generated ${column.metadata.identity.generation === "byDefault" ? "by default" : "always"} as identity`);
+  } else if (column.metadata.generatedValue) {
+    clauses.push(`generated always as (${renderDdlExpression(column.metadata.generatedValue, state, dialect)}) stored`);
   } else if (column.metadata.defaultValue) {
-    clauses.push(`default ${renderExpression(column.metadata.defaultValue, state, dialect)}`);
+    clauses.push(`default ${renderDdlExpression(column.metadata.defaultValue, state, dialect)}`);
   }
   if (!column.metadata.nullable) {
     clauses.push("not null");
   }
   return clauses.join(" ");
 };
-var renderCheckPredicate = (predicate, state, dialect) => {
-  return renderExpression(predicate, state, dialect);
-};
 var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
   const table = targetSource.source;
   const fields2 = table[TypeId4].fields;
   const definitions = Object.entries(fields2).map(([columnName, column]) => renderColumnDefinition(dialect, state, columnName, column));
-  for (const option of table[OptionsSymbol]) {
-    switch (option.kind) {
+  for (const option2 of table[OptionsSymbol]) {
+    switch (option2.kind) {
       case "primaryKey":
-        definitions.push(`primary key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(option2.name)} ` : ""}primary key (${option2.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "unique":
-        definitions.push(`unique (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`);
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(option2.name)} ` : ""}unique${option2.nullsNotDistinct ? " nulls not distinct" : ""} (${option2.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "foreignKey": {
-        const reference = option.references();
-        definitions.push(`foreign key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`);
+        const reference = option2.references();
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(option2.name)} ` : ""}foreign key (${option2.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option2.onDelete ? ` on delete ${option2.onDelete.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option2.onUpdate ? ` on update ${option2.onUpdate.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       }
       case "check":
-        definitions.push(`constraint ${dialect.quoteIdentifier(option.name)} check (${renderCheckPredicate(option.predicate, state, dialect)})`);
+        definitions.push(`constraint ${dialect.quoteIdentifier(option2.name)} check (${renderDdlExpression(option2.predicate, state, dialect)})${option2.noInherit ? " no inherit" : ""}`);
         break;
       case "index":
         break;
@@ -56437,7 +57716,7 @@ var extractJsonPathSegments = (node) => {
       return [key(segment)];
     }
     if (typeof segment === "number") {
-      return [index2(segment)];
+      return [index3(segment)];
     }
     if (segment !== null && typeof segment === "object" && SegmentTypeId in segment) {
       return [segment];
@@ -56496,6 +57775,7 @@ var renderPostgresJsonPathArray = (segments, state, dialect) => `array[${segment
       throw new Error("Postgres JSON traversal requires exact key/index segments");
   }
 }).join(", ")}]`;
+var renderPostgresTextLiteral = (value, state, dialect) => `cast(${dialect.renderLiteral(value, state)} as text)`;
 var renderPostgresJsonAccessStep = (segment, textMode, state, dialect) => {
   switch (segment.kind) {
     case "key":
@@ -56513,6 +57793,7 @@ var renderPostgresJsonValue = (value, state, dialect) => {
   const rendered = renderExpression(value, state, dialect);
   return value[TypeId].dbType.kind === "jsonb" ? rendered : `cast(${rendered} as jsonb)`;
 };
+var renderPostgresJsonKind = (value) => value[TypeId].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath = (value, state, dialect) => {
   if (isJsonPathValue(value)) {
     return dialect.renderLiteral(renderJsonPathStringLiteral(value.segments), state);
@@ -56525,23 +57806,39 @@ var renderJsonOpaquePath = (value, state, dialect) => {
   }
   throw new Error("Unsupported SQL/JSON path input");
 };
-var renderFunctionCall = (name, args, state, dialect) => {
+var renderFunctionCall = (name2, args, state, dialect) => {
+  if (name2 === "array") {
+    return `ARRAY[${args.map((arg) => renderExpression(arg, state, dialect)).join(", ")}]`;
+  }
+  if (name2 === "extract" && args.length === 2) {
+    const field = args[0];
+    const source = args[1];
+    if (field === undefined) {
+      throw new Error("Unsupported SQL extract expression");
+    }
+    if (source === undefined) {
+      throw new Error("Unsupported SQL extract expression");
+    }
+    const fieldRuntime = isExpression3(field) && field[TypeId].dbType.kind === "text" && typeof field[TypeId].runtime === "string" ? field[TypeId].runtime : undefined;
+    const renderedField = fieldRuntime ?? renderExpression(field, state, dialect);
+    return `extract(${renderedField} from ${renderExpression(source, state, dialect)})`;
+  }
   const renderedArgs = args.map((arg) => renderExpression(arg, state, dialect)).join(", ");
   if (args.length === 0) {
-    switch (name) {
+    switch (name2) {
       case "current_date":
       case "current_time":
       case "current_timestamp":
       case "localtime":
       case "localtimestamp":
-        return name;
+        return name2;
       default:
-        return `${name}()`;
+        return `${name2}()`;
     }
   }
-  return `${name}(${renderedArgs})`;
+  return `${name2}(${renderedArgs})`;
 };
-var renderJsonExpression = (ast, state, dialect) => {
+var renderJsonExpression = (expression, ast, state, dialect) => {
   const kind = typeof ast.kind === "string" ? ast.kind : undefined;
   if (!kind) {
     return;
@@ -56549,6 +57846,8 @@ var renderJsonExpression = (ast, state, dialect) => {
   const base = extractJsonBase(ast);
   const segments = extractJsonPathSegments(ast);
   const exact = segments.every((segment) => segment.kind === "key" || segment.kind === "index");
+  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression(expression) ? renderPostgresJsonKind(expression) : undefined;
+  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression(base) ? renderPostgresJsonKind(base) : undefined;
   switch (kind) {
     case "jsonGet":
     case "jsonPath":
@@ -56569,7 +57868,7 @@ var renderJsonExpression = (ast, state, dialect) => {
         }
         const jsonPathLiteral = dialect.renderLiteral(renderJsonPathStringLiteral(segments), state);
         const queried = `jsonb_path_query_first(${renderPostgresJsonValue(base, state, dialect)}, ${jsonPathLiteral})`;
-        return textMode ? `cast(${queried} as text)` : queried;
+        return textMode ? `(${queried} #>> '{}')` : queried;
       }
       if (dialect.name === "mysql") {
         const extracted = `json_extract(${baseSql}, ${renderMySqlJsonPath(segments, state, dialect)})`;
@@ -56591,12 +57890,12 @@ var renderJsonExpression = (ast, state, dialect) => {
       }
       if (dialect.name === "postgres") {
         if (kind === "jsonHasAnyKeys") {
-          return `(${baseSql} ?| ${renderPostgresJsonPathArray(keys, state, dialect)})`;
+          return `(${baseSql} ?| array[${keys.map((key2) => renderPostgresTextLiteral(String(key2), state, dialect)).join(", ")}])`;
         }
         if (kind === "jsonHasAllKeys") {
-          return `(${baseSql} ?& ${renderPostgresJsonPathArray(keys, state, dialect)})`;
+          return `(${baseSql} ?& array[${keys.map((key2) => renderPostgresTextLiteral(String(key2), state, dialect)).join(", ")}])`;
         }
-        return `(${baseSql} ? ${dialect.renderLiteral(keys[0], state)})`;
+        return `(${baseSql} ? ${renderPostgresTextLiteral(String(keys[0]), state, dialect)})`;
       }
       if (dialect.name === "mysql") {
         const mode = kind === "jsonHasAllKeys" ? "all" : "one";
@@ -56625,7 +57924,7 @@ var renderJsonExpression = (ast, state, dialect) => {
         renderExpression(entry.value, state, dialect)
       ]);
       if (dialect.name === "postgres") {
-        return `jsonb_build_object(${renderedEntries.join(", ")})`;
+        return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`;
       }
       if (dialect.name === "mysql") {
         return `json_object(${renderedEntries.join(", ")})`;
@@ -56636,7 +57935,7 @@ var renderJsonExpression = (ast, state, dialect) => {
       const values = Array.isArray(ast.values) ? ast.values : [];
       const renderedValues = values.map((value) => renderExpression(value, state, dialect)).join(", ");
       if (dialect.name === "postgres") {
-        return `jsonb_build_array(${renderedValues})`;
+        return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`;
       }
       if (dialect.name === "mysql") {
         return `json_array(${renderedValues})`;
@@ -56670,7 +57969,8 @@ var renderJsonExpression = (ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        return `jsonb_typeof(${renderPostgresJsonValue(base, state, dialect)})`;
+        const baseSql = renderExpression(base, state, dialect);
+        return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof(${baseSql})`;
       }
       if (dialect.name === "mysql") {
         return `json_type(${renderExpression(base, state, dialect)})`;
@@ -56681,8 +57981,11 @@ var renderJsonExpression = (ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        const jsonb = renderPostgresJsonValue(base, state, dialect);
-        return `(case when jsonb_typeof(${jsonb}) = 'array' then jsonb_array_length(${jsonb}) when jsonb_typeof(${jsonb}) = 'object' then jsonb_object_length(${jsonb}) else null end)`;
+        const baseSql = renderExpression(base, state, dialect);
+        const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`;
+        const arrayLength = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_array_length`;
+        const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`;
+        return `(case when ${typeOf}(${baseSql}) = 'array' then ${arrayLength}(${baseSql}) when ${typeOf}(${baseSql}) = 'object' then (select count(*)::int from ${objectKeys}(${baseSql})) else null end)`;
       }
       if (dialect.name === "mysql") {
         return `json_length(${renderExpression(base, state, dialect)})`;
@@ -56693,8 +57996,10 @@ var renderJsonExpression = (ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        const jsonb = renderPostgresJsonValue(base, state, dialect);
-        return `(case when jsonb_typeof(${jsonb}) = 'object' then array(select jsonb_object_keys(${jsonb})) else null end)`;
+        const baseSql = renderExpression(base, state, dialect);
+        const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`;
+        const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`;
+        return `(case when ${typeOf}(${baseSql}) = 'object' then array(select ${objectKeys}(${baseSql})) else null end)`;
       }
       if (dialect.name === "mysql") {
         return `json_keys(${renderExpression(base, state, dialect)})`;
@@ -56705,7 +58010,7 @@ var renderJsonExpression = (ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        return `jsonb_strip_nulls(${renderPostgresJsonValue(base, state, dialect)})`;
+        return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_strip_nulls(${renderExpression(base, state, dialect)})`;
       }
       unsupportedJsonFeature(dialect, "jsonStripNulls");
       return;
@@ -56924,7 +58229,7 @@ var renderQueryAst = (ast, state, dialect) => {
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
           const rowCount = unnestSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index3) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state)).join(", ")})`).join(", ");
+          const rows = Array.from({ length: rowCount }, (_, index4) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index4], state)).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -57129,7 +58434,7 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
   };
   const renderUnnestRows = (arrays, columnNames) => {
     const rowCount = arrays[columnNames[0]].length;
-    const rows = Array.from({ length: rowCount }, (_, index3) => Object.fromEntries(columnNames.map((columnName) => [columnName, arrays[columnName][index3]])));
+    const rows = Array.from({ length: rowCount }, (_, index4) => Object.fromEntries(columnNames.map((columnName) => [columnName, arrays[columnName][index4]])));
     return renderSelectRows(rows, columnNames);
   };
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "cte") {
@@ -57175,7 +58480,7 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
 };
 var renderExpression = (expression, state, dialect) => {
   const rawAst = expression[TypeId2];
-  const jsonSql = renderJsonExpression(rawAst, state, dialect);
+  const jsonSql = renderJsonExpression(expression, rawAst, state, dialect);
   if (jsonSql !== undefined) {
     return jsonSql;
   }
@@ -57183,7 +58488,7 @@ var renderExpression = (expression, state, dialect) => {
   const renderComparisonOperator = (operator) => operator === "eq" ? "=" : operator === "neq" ? "<>" : operator === "lt" ? "<" : operator === "lte" ? "<=" : operator === "gt" ? ">" : ">=";
   switch (ast.kind) {
     case "column":
-      return `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`;
+      return ast.tableName.length === 0 ? dialect.quoteIdentifier(ast.columnName) : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`;
     case "literal":
       return dialect.renderLiteral(ast.value, state);
     case "excluded":
@@ -57208,6 +58513,14 @@ var renderExpression = (expression, state, dialect) => {
       return `(${renderExpression(ast.left, state, dialect)} like ${renderExpression(ast.right, state, dialect)})`;
     case "ilike":
       return dialect.name === "postgres" ? `(${renderExpression(ast.left, state, dialect)} ilike ${renderExpression(ast.right, state, dialect)})` : `(lower(${renderExpression(ast.left, state, dialect)}) like lower(${renderExpression(ast.right, state, dialect)}))`;
+    case "regexMatch":
+      return dialect.name === "postgres" ? `(${renderExpression(ast.left, state, dialect)} ~ ${renderExpression(ast.right, state, dialect)})` : `(${renderExpression(ast.left, state, dialect)} regexp ${renderExpression(ast.right, state, dialect)})`;
+    case "regexIMatch":
+      return dialect.name === "postgres" ? `(${renderExpression(ast.left, state, dialect)} ~* ${renderExpression(ast.right, state, dialect)})` : `(${renderExpression(ast.left, state, dialect)} regexp ${renderExpression(ast.right, state, dialect)})`;
+    case "regexNotMatch":
+      return dialect.name === "postgres" ? `(${renderExpression(ast.left, state, dialect)} !~ ${renderExpression(ast.right, state, dialect)})` : `(${renderExpression(ast.left, state, dialect)} not regexp ${renderExpression(ast.right, state, dialect)})`;
+    case "regexNotIMatch":
+      return dialect.name === "postgres" ? `(${renderExpression(ast.left, state, dialect)} !~* ${renderExpression(ast.right, state, dialect)})` : `(${renderExpression(ast.left, state, dialect)} not regexp ${renderExpression(ast.right, state, dialect)})`;
     case "isDistinctFrom":
       return dialect.name === "mysql" ? `(not (${renderExpression(ast.left, state, dialect)} <=> ${renderExpression(ast.right, state, dialect)}))` : `(${renderExpression(ast.left, state, dialect)} is distinct from ${renderExpression(ast.right, state, dialect)})`;
     case "isNotDistinctFrom":
@@ -57328,9 +58641,9 @@ var renderPostgresPlan = (plan) => {
 };
 
 // src/internal/renderer.ts
-var TypeId8 = Symbol.for("effect-qb/Renderer");
-function make5(dialect, render) {
-  const implementation = render ?? (dialect === "postgres" ? renderPostgresPlan : undefined);
+var TypeId9 = Symbol.for("effect-qb/Renderer");
+function make5(dialect, render2) {
+  const implementation = render2 ?? (dialect === "postgres" ? renderPostgresPlan : undefined);
   if (!implementation) {
     throw new Error(`No built-in renderer for dialect: ${dialect}`);
   }
@@ -57345,7 +58658,7 @@ function make5(dialect, render) {
         params: rendered.params ?? [],
         projections,
         dialect,
-        [TypeId8]: {
+        [TypeId9]: {
           row: undefined,
           dialect
         }
@@ -57448,6 +58761,10 @@ __export(exports_query2, {
   rightJoin: () => rightJoin,
   returning: () => returning,
   releaseSavepoint: () => releaseSavepoint,
+  regexNotMatch: () => regexNotMatch,
+  regexNotIMatch: () => regexNotIMatch,
+  regexMatch: () => regexMatch,
+  regexIMatch: () => regexIMatch,
   overlaps: () => overlaps,
   orderBy: () => orderBy,
   or: () => or,
@@ -57504,6 +58821,7 @@ __export(exports_query2, {
   compareAny: () => compareAny,
   compareAll: () => compareAll,
   commit: () => commit,
+  column: () => column,
   cast: () => cast,
   case: () => case_,
   between: () => between,
@@ -57513,6 +58831,7 @@ __export(exports_query2, {
   all: () => all
 });
 var literal = mysqlQuery.literal;
+var column = mysqlQuery.column;
 var cast = mysqlQuery.cast;
 var type = mysqlQuery.type;
 var eq = mysqlQuery.eq;
@@ -57525,6 +58844,10 @@ var isNull = mysqlQuery.isNull;
 var isNotNull = mysqlQuery.isNotNull;
 var like = mysqlQuery.like;
 var ilike = mysqlQuery.ilike;
+var regexMatch = mysqlQuery.regexMatch;
+var regexIMatch = mysqlQuery.regexIMatch;
+var regexNotMatch = mysqlQuery.regexNotMatch;
+var regexNotIMatch = mysqlQuery.regexNotIMatch;
 var and = mysqlQuery.and;
 var or = mysqlQuery.or;
 var not = mysqlQuery.not;
@@ -57601,38 +58924,38 @@ __export(exports_table2, {
   primaryKey: () => primaryKey4,
   options: () => options2,
   make: () => make7,
-  index: () => index3,
-  foreignKey: () => foreignKey2,
+  index: () => index4,
+  foreignKey: () => foreignKey3,
   check: () => check2,
   alias: () => alias2,
-  TypeId: () => TypeId9,
+  TypeId: () => TypeId10,
   OptionsSymbol: () => OptionsSymbol2,
   Class: () => Class2
 });
-var TypeId9 = TypeId4;
+var TypeId10 = TypeId4;
 var OptionsSymbol2 = OptionsSymbol;
 var options2 = options;
-var make7 = (name, fields2, schemaName = undefined) => make2(name, fields2, schemaName);
+var make7 = (name2, fields2, schemaName = undefined) => make2(name2, fields2, schemaName);
 var schema4 = (schemaName) => ({
   schemaName,
-  table: (name, fields2, ...declaredOptions) => schema3(schemaName).table(name, fields2, ...declaredOptions)
+  table: (name2, fields2, ...declaredOptions) => schema3(schemaName).table(name2, fields2, ...declaredOptions)
 });
 var alias2 = (table, aliasName) => alias(table, aliasName);
-var Class2 = (name, schemaName = undefined) => {
-  const base = Class(name, schemaName);
+var Class2 = (name2, schemaName = undefined) => {
+  const base = Class(name2, schemaName);
   return base;
 };
 var primaryKey4 = primaryKey3;
 var unique4 = unique3;
-var index3 = index;
-var foreignKey2 = (columns, target, referencedColumns) => foreignKey(columns, target, referencedColumns);
+var index4 = index2;
+var foreignKey3 = (columns, target, referencedColumns) => foreignKey2(columns, target, referencedColumns);
 var check2 = check;
 // src/mysql/renderer.ts
 var exports_renderer2 = {};
 __export(exports_renderer2, {
   mysql: () => mysql2,
   make: () => make8,
-  TypeId: () => TypeId8
+  TypeId: () => TypeId9
 });
 var make8 = () => make5("mysql", renderMysqlPlan);
 var mysql2 = make8();