effect-qb 0.17.0 → 0.19.0

package/dist/postgres/metadata.js

@@ -25,7 +25,7 @@ __export(exports_metadata, {
 });
 
 // src/internal/table.ts
-import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
 
 // src/internal/row-set.ts
 var exports_row_set = {};
@@ -142,7 +142,7 @@ var remapColumnDefinition = (column, options = {}) => {
   }
   return next;
 };
-var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
+var bindColumn = (tableName, columnName, column, baseTableName, schemaName, casing) => {
   const brandName = `${tableName}.${columnName}`;
   const schema = column.metadata.brand === true ? Schema.brand(brandName)(column.schema) : column.schema;
   const bound = attachPipe(Object.create(ColumnProto));
@@ -170,11 +170,64 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
     tableName,
     columnName,
     baseTableName,
-    schemaName
+    schemaName,
+    casing
   };
   return bound;
 };
 
+// src/internal/schema-expression.ts
+import { parse, toSql } from "pgsql-ast-parser";
+import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
+var TypeId4 = Symbol.for("effect-qb/SchemaExpression");
+var SchemaExpressionProto = {
+  pipe() {
+    return pipeArguments2(this, arguments);
+  }
+};
+var attachPipe2 = (value) => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments2(value, arguments);
+    }
+  });
+  return value;
+};
+var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId4 in value);
+var fromAst = (ast) => {
+  const expression = attachPipe2(Object.create(SchemaExpressionProto));
+  expression[TypeId4] = {
+    ast
+  };
+  return expression;
+};
+var fromSql = (sql) => {
+  const expression = attachPipe2(Object.create(SchemaExpressionProto));
+  expression[TypeId4] = {
+    sql: sql.trim()
+  };
+  return expression;
+};
+var parseExpression = (sql) => fromAst(parse(sql, "expr"));
+var toAst = (expression) => {
+  const ast = expression[TypeId4].ast;
+  if (ast !== undefined) {
+    return ast;
+  }
+  return parse(render(expression), "expr");
+};
+var render = (expression) => expression[TypeId4].sql ?? toSql.expr(toAst(expression));
+var normalize = (expression) => (() => {
+  const sql = render(expression);
+  try {
+    return parseExpression(sql);
+  } catch {
+    return fromSql(sql);
+  }
+})();
+
 // src/internal/table-options.ts
 var referentialActionError = "Foreign key action must be noAction, restrict, cascade, setNull, or setDefault";
 var renderReferentialAction = (action) => {
@@ -192,17 +245,11 @@ var renderReferentialAction = (action) => {
   }
   throw new Error(referentialActionError);
 };
-var validateReferentialAction = (action) => {
-  if (action !== undefined) {
-    renderReferentialAction(action);
-  }
-};
 var normalizeColumnList = (columns) => {
-  const normalized = Array.isArray(columns) ? [...columns] : [columns];
-  if (normalized.length === 0) {
-    throw new Error("Table options require at least one column");
+  if (typeof columns === "string") {
+    return [columns];
   }
-  return normalized;
+  return [columns[0], ...columns.slice(1)];
 };
 var collectInlineOptions = (fields) => {
   const options = [];
@@ -224,8 +271,6 @@ var collectInlineOptions = (fields) => {
       });
     }
     if (column.metadata.references) {
-      validateReferentialAction(column.metadata.references.onUpdate);
-      validateReferentialAction(column.metadata.references.onDelete);
       const local = [columnName];
       options.push({
         kind: "foreignKey",
@@ -236,6 +281,7 @@ var collectInlineOptions = (fields) => {
           return {
             tableName: bound.baseTableName,
             schemaName: bound.schemaName,
+            casing: bound.casing,
             columns: [bound.columnName]
           };
         },
@@ -268,91 +314,50 @@ var collectInlineOptions = (fields) => {
 };
 var resolvePrimaryKeyColumns = (fields, declaredOptions) => {
   const inline = Object.entries(fields).filter(([, column]) => column.metadata.primaryKey).map(([key]) => key);
-  const explicit = declaredOptions.filter((option) => option.kind === "primaryKey").map((option) => option.columns);
-  if (explicit.length > 1) {
-    throw new Error("Only one primary key declaration is allowed");
-  }
+  const explicit = declaredOptions.flatMap((option) => {
+    if (typeof option !== "object" || option === null || !("kind" in option) || option.kind !== "primaryKey") {
+      return [];
+    }
+    return Array.isArray(option.columns) ? [option.columns] : [];
+  });
   if (explicit.length === 0) {
     return inline;
   }
   const tablePrimaryKey = [...explicit[0]];
-  if (inline.length > 0) {
-    const same = inline.length === tablePrimaryKey.length && inline.every((column) => tablePrimaryKey.includes(column));
-    if (!same) {
-      throw new Error("Inline primary keys conflict with table-level primary key declaration");
-    }
-  }
   return tablePrimaryKey;
 };
 var validateOptions = (tableName, fields, options) => {
-  const knownColumns = new Set(Object.keys(fields));
-  for (const option of options) {
+  const tableOptions = Array.isArray(options) ? options : [options];
+  for (const option of tableOptions) {
+    if (typeof option !== "object" || option === null || !("kind" in option)) {
+      continue;
+    }
     switch (option.kind) {
       case "index":
       case "primaryKey":
       case "unique":
       case "foreignKey": {
-        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 columns) {
-          if (!knownColumns.has(column)) {
-            throw new Error(`Unknown column '${column}' on table '${tableName}'`);
-          }
-        }
-        if (option.kind === "foreignKey") {
-          validateReferentialAction(option.onUpdate);
-          validateReferentialAction(option.onDelete);
-          const reference = option.references();
-          if (reference.columns.length !== columns.length) {
-            throw new Error(`Foreign key on table '${tableName}' must reference the same number of columns`);
-          }
-          if (reference.knownColumns) {
-            const referenced = new Set(reference.knownColumns);
-            for (const column of reference.columns) {
-              if (!referenced.has(column)) {
-                throw new Error(`Unknown referenced column '${column}' on table '${reference.tableName}'`);
-              }
-            }
-          }
-        }
         if (option.kind === "index") {
-          for (const column of option.include ?? []) {
-            if (!knownColumns.has(column)) {
-              throw new Error(`Unknown included column '${column}' on table '${tableName}'`);
+          const keys = Array.isArray(option.keys) ? option.keys : [];
+          for (const key of keys) {
+            if (typeof key !== "object" || key === null || !("kind" in key)) {
+              continue;
             }
           }
-          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 (columns.length === 0 && (option.keys === undefined || option.keys.length === 0)) {
-            throw new Error(`Index on table '${tableName}' requires at least one column or key`);
-          }
         }
         break;
       }
       case "check": {
         break;
       }
-    }
-  }
-  for (const column of resolvePrimaryKeyColumns(fields, options)) {
-    if (fields[column].metadata.nullable) {
-      throw new Error(`Primary key column '${String(column)}' cannot be nullable`);
+      default:
+        break;
     }
   }
 };
 
 // src/internal/schema-derivation.ts
-import * as VariantSchema from "@effect/experimental/VariantSchema";
 import * as Schema2 from "effect/Schema";
-var TableSchema = VariantSchema.make({
-  variants: ["select", "insert", "update"],
-  defaultVariant: "select"
-});
 var maybeBrandSchema = (column, tableName, columnName) => column.metadata.brand === true ? Schema2.brand(`${tableName}.${columnName}`)(column.schema) : column.schema;
 var selectSchema = (column, tableName, columnName) => column.metadata.nullable ? Schema2.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
 var insertSchema = (column, tableName, columnName) => {
@@ -369,87 +374,196 @@ var updateSchema = (column, tableName, columnName, isPrimaryKey) => {
   const base = column.metadata.nullable ? Schema2.NullOr(maybeBrandSchema(column, tableName, columnName)) : maybeBrandSchema(column, tableName, columnName);
   return Schema2.optional(base);
 };
-var deriveSchemas = (tableName, fields, primaryKeyColumns) => {
+var fieldSchemaForVariant = (variant, column, tableName, columnName, primaryKeySet) => {
+  switch (variant) {
+    case "select":
+      return selectSchema(column, tableName, columnName);
+    case "insert":
+      return insertSchema(column, tableName, columnName);
+    case "update":
+      return updateSchema(column, tableName, columnName, primaryKeySet.has(columnName));
+  }
+};
+var deriveSchema = (variant, tableName, fields, primaryKeyColumns) => {
   const primaryKeySet = new Set(primaryKeyColumns);
-  const variants = {};
+  const structFields = {};
   for (const [key, column] of Object.entries(fields)) {
-    const config = {
-      select: selectSchema(column, tableName, key),
-      insert: undefined,
-      update: undefined
-    };
-    const insert = insertSchema(column, tableName, key);
-    const update = updateSchema(column, tableName, key, primaryKeySet.has(key));
-    if (insert !== undefined) {
-      config.insert = insert;
-    } else {
-      delete config.insert;
+    const schema = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet);
+    if (schema !== undefined) {
+      structFields[key] = schema;
     }
-    if (update !== undefined) {
-      config.update = update;
-    } else {
-      delete config.update;
-    }
-    variants[key] = TableSchema.Field(config);
   }
-  const struct = TableSchema.Struct(variants);
-  return {
-    select: TableSchema.extract(struct, "select"),
-    insert: TableSchema.extract(struct, "insert"),
-    update: TableSchema.extract(struct, "update")
-  };
+  return Schema2.Struct(structFields);
 };
+var deriveSelectSchema = (tableName, fields, primaryKeyColumns) => deriveSchema("select", tableName, fields, primaryKeyColumns);
+var deriveInsertSchema = (tableName, fields, primaryKeyColumns) => deriveSchema("insert", tableName, fields, primaryKeyColumns);
+var deriveUpdateSchema = (tableName, fields, primaryKeyColumns) => deriveSchema("update", tableName, fields, primaryKeyColumns);
+
+// src/internal/casing.ts
+var TypeId5 = Symbol.for("effect-qb/Casing");
+var merge = (base, override) => {
+  if (base === undefined) {
+    return override;
+  }
+  if (override === undefined) {
+    return base;
+  }
+  return { ...base, ...override };
+};
+var words = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter((part) => part.length > 0);
+var capitalize = (value) => value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
+var lowerWords = (name) => words(name).map((part) => part.toLowerCase());
+var applyNamedStyle = (style, name) => {
+  switch (style) {
+    case "preserve":
+      return name;
+    case "snake_case":
+      return lowerWords(name).join("_");
+    case "camelCase": {
+      const parts = lowerWords(name);
+      const [head, ...tail] = parts;
+      return head === undefined ? "" : `${head}${tail.map(capitalize).join("")}`;
+    }
+    case "PascalCase":
+      return lowerWords(name).map(capitalize).join("");
+    case "kebab-case":
+      return lowerWords(name).join("-");
+    case "SCREAMING_SNAKE_CASE":
+      return lowerWords(name).join("_").toUpperCase();
+  }
+};
+var apply = (style, name) => {
+  if (style === undefined) {
+    return name;
+  }
+  return typeof style === "function" ? style(name) : applyNamedStyle(style, name);
+};
+var applyCategory = (options, category, name) => apply(options?.[category], name);
 
 // src/internal/table.ts
-var TypeId4 = Symbol.for("effect-qb/Table");
+var TypeId6 = Symbol.for("effect-qb/Table");
 var OptionsSymbol = Symbol.for("effect-qb/Table/normalizedOptions");
 var options = Symbol.for("effect-qb/Table/declaredOptions");
 var CacheSymbol = Symbol.for("effect-qb/Table/cache");
+var SchemaCacheSymbol = Symbol.for("effect-qb/Table/schemaCache");
 var DeclaredOptionsSymbol = Symbol.for("effect-qb/Table/factoryDeclaredOptions");
 var TableProto = {
   pipe() {
-    return pipeArguments2(this, arguments);
+    return pipeArguments3(this, arguments);
   }
 };
-var attachPipe2 = (value) => {
+var attachPipe3 = (value) => {
   Object.defineProperty(value, "pipe", {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments2(value, arguments);
+      return pipeArguments3(value, arguments);
     }
   });
   return value;
 };
-var buildArtifacts = (name, fields, declaredOptions, schemaName) => {
+var buildArtifacts = (name, fields, declaredOptions, schemaName, casing) => {
   const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions];
   validateFieldDialects(name, fields);
   validateOptions(name, fields, declaredOptions);
   const primaryKey = resolvePrimaryKeyColumns(fields, declaredOptions);
-  const columns = Object.fromEntries(Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName)]));
-  const schemas = deriveSchemas(name, fields, primaryKey);
+  const columns = Object.fromEntries(Object.entries(fields).map(([key, column]) => [key, bindColumn(name, key, column, name, schemaName, casing)]));
   return {
     columns,
-    schemas,
     normalizedOptions,
     primaryKey
   };
 };
-var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema", schemaName, schemaMode = "default") => {
+var getSchemaCache = (table) => {
+  const target = table;
+  if (target[SchemaCacheSymbol] !== undefined) {
+    return target[SchemaCacheSymbol];
+  }
+  const cache = {};
+  Object.defineProperty(table, SchemaCacheSymbol, {
+    configurable: true,
+    value: cache
+  });
+  return cache;
+};
+var deriveTableSchema = (table, variant) => {
+  const state = table[TypeId6];
+  switch (variant) {
+    case "select":
+      return deriveSelectSchema(state.name, state.fields, state.primaryKey);
+    case "insert":
+      return deriveInsertSchema(state.name, state.fields, state.primaryKey);
+    case "update":
+      return deriveUpdateSchema(state.name, state.fields, state.primaryKey);
+  }
+};
+var schemaFor = (table, variant) => {
+  const cache = getSchemaCache(table);
+  const cached = cache[variant];
+  if (cached !== undefined) {
+    return cached;
+  }
+  const schema = deriveTableSchema(table, variant);
+  cache[variant] = schema;
+  return schema;
+};
+function selectSchema2(table) {
+  return schemaFor(table, "select");
+}
+function insertSchema2(table) {
+  return schemaFor(table, "insert");
+}
+function updateSchema2(table) {
+  return schemaFor(table, "update");
+}
+var schemasFor = (table) => {
+  const cache = getSchemaCache(table);
+  if (cache.schemas !== undefined) {
+    return cache.schemas;
+  }
+  const schemas = {};
+  Object.defineProperties(schemas, {
+    select: {
+      enumerable: true,
+      get: () => selectSchema2(table)
+    },
+    insert: {
+      enumerable: true,
+      get: () => insertSchema2(table)
+    },
+    update: {
+      enumerable: true,
+      get: () => updateSchema2(table)
+    }
+  });
+  cache.schemas = schemas;
+  return schemas;
+};
+var defineSchemasGetter = (table) => {
+  Object.defineProperty(table, "schemas", {
+    configurable: true,
+    enumerable: true,
+    get() {
+      return schemasFor(table);
+    }
+  });
+};
+var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema", schemaName, schemaMode = "default", casing) => {
   const resolvedSchemaName = schemaMode === "explicit" ? schemaName : "public";
-  const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName);
+  const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName, casing);
   const dialect = resolveFieldDialect(fields);
-  const table = attachPipe2(Object.create(TableProto));
+  const table = attachPipe3(Object.create(TableProto));
   table.name = name;
   table.columns = artifacts.columns;
-  table.schemas = artifacts.schemas;
-  table[TypeId4] = {
+  defineSchemasGetter(table);
+  table[TypeId6] = {
     name,
     baseName,
     schemaName: resolvedSchemaName,
     fields,
     primaryKey: artifacts.primaryKey,
-    kind
+    kind,
+    casing
   };
   table[TypeId] = {
     selection: artifacts.columns,
@@ -480,22 +594,17 @@ var applyDeclaredOptions = (table, declaredOptions) => {
   }
   return declaredOptions.reduce((current, option) => option(current), table);
 };
-var validateClassOptions = (declaredOptions) => {
-  for (const option of declaredOptions) {
-    if (option.kind === "primaryKey") {
-      throw new Error("Table.Class does not support table-level primary keys; declare primary keys inline on columns");
-    }
-  }
-};
 var resolveFieldDialect = (fields) => {
   const dialects = [...new Set(Object.values(fields).map((field) => field.metadata.dbType.dialect))];
   if (dialects.length === 0) {
     throw new Error("Cannot infer table dialect from an empty field set");
   }
-  if (dialects.length > 1) {
+  const concreteDialects = dialects.filter((dialect) => dialect !== "standard");
+  const uniqueConcreteDialects = [...new Set(concreteDialects)];
+  if (uniqueConcreteDialects.length > 1) {
     throw new Error(`Mixed table dialects are not supported: ${dialects.join(", ")}`);
   }
-  return dialects[0];
+  return uniqueConcreteDialects[0] ?? "standard";
 };
 var validateFieldDialects = (tableName, fields) => {
   try {
@@ -509,15 +618,13 @@ var ensureClassArtifacts = (self) => {
   if (cached) {
     return cached;
   }
-  const state = self[TypeId4];
+  const state = self[TypeId6];
   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 table = applyDeclaredOptions(makeTable(state.name, state.fields, [], state.name, "schema", state.schemaName, state.schemaName === undefined || state.schemaName === "public" ? "default" : "explicit", state.casing), classOptions);
   const artifacts = {
     columns: table.columns,
-    schemas: table.schemas,
     normalizedOptions: table[OptionsSymbol],
-    primaryKey: table[TypeId4].primaryKey
+    primaryKey: table[TypeId6].primaryKey
   };
   Object.defineProperty(self, CacheSymbol, {
     configurable: true,
@@ -526,43 +633,40 @@ var ensureClassArtifacts = (self) => {
   return artifacts;
 };
 var appendOption = (table, option) => {
-  const state = table[TypeId4];
-  if (state.kind !== "schema") {
-    throw new Error("Table options can only be applied to schema tables, not aliased query sources");
-  }
-  return makeTable(state.name, state.fields, [...table[DeclaredOptionsSymbol], option], state.baseName, state.kind, state.schemaName, "explicit");
+  const state = table[TypeId6];
+  return makeTable(state.name, state.fields, [...table[DeclaredOptionsSymbol], option], state.baseName, state.kind, state.schemaName, "explicit", state.casing);
 };
 var makeOption = (option) => {
-  const builder = (table) => appendOption(table, option);
-  builder.option = option;
-  return builder;
+  return attachPipe3(Object.assign((table, ..._validation) => appendOption(table, option), { option }));
 };
 var option = (spec) => makeOption(spec);
-function make2(name, fields, schemaName) {
+function make(name, fields, schemaName) {
   const resolvedSchemaName = arguments.length >= 3 ? schemaName : "public";
   return makeTable(name, fields, [], name, "schema", resolvedSchemaName, arguments.length >= 3 ? "explicit" : "default");
 }
-var schema = (schemaName) => {
-  const table = (name, fields, ...options2) => applyDeclaredOptions(makeTable(name, fields, [], name, "schema", schemaName, "explicit"), options2);
-  return {
-    schemaName,
-    table
-  };
+var withCasing = (table, casing) => {
+  const state = table[TypeId6];
+  return makeTable(state.name, state.fields, table[DeclaredOptionsSymbol], state.baseName, state.kind, state.schemaName, "explicit", merge(state.casing, casing));
+};
+var withSchema = (table, schemaName, schemaCasing) => {
+  const state = table[TypeId6];
+  return makeTable(state.name, state.fields, table[DeclaredOptionsSymbol], state.baseName, state.kind, schemaName, "explicit", merge(schemaCasing, state.casing));
 };
 var alias = (table, aliasName) => {
-  const state = table[TypeId4];
-  const columns = Object.fromEntries(Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column, state.baseName, state.schemaName)]));
-  const aliased = attachPipe2(Object.create(TableProto));
+  const state = table[TypeId6];
+  const columns = Object.fromEntries(Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column, state.baseName, state.schemaName, state.casing)]));
+  const aliased = attachPipe3(Object.create(TableProto));
   aliased.name = aliasName;
   aliased.columns = columns;
-  aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey);
-  aliased[TypeId4] = {
+  defineSchemasGetter(aliased);
+  aliased[TypeId6] = {
     name: aliasName,
     baseName: state.baseName,
     schemaName: state.schemaName,
     fields: state.fields,
     primaryKey: state.primaryKey,
-    kind: "alias"
+    kind: "alias",
+    casing: state.casing
   };
   aliased[TypeId] = {
     selection: columns,
@@ -596,11 +700,10 @@ function Class(name, schemaName) {
         return ensureClassArtifacts(this).columns;
       }
       static get schemas() {
-        return ensureClassArtifacts(this).schemas;
+        return schemasFor(this);
       }
-      static get [TypeId4]() {
+      static get [TypeId6]() {
         const declaredOptions = extractDeclaredOptions(this[options]);
-        validateClassOptions(declaredOptions);
         return {
           name,
           baseName: name,
@@ -629,7 +732,7 @@ function Class(name, schemaName) {
         return ensureClassArtifacts(this).normalizedOptions;
       }
       static pipe() {
-        return pipeArguments2(this, arguments);
+        return pipeArguments3(this, arguments);
       }
     }
     for (const key of Object.keys(fields)) {
@@ -660,10 +763,11 @@ var foreignKey = (columns, target, referencedColumns) => makeOption({
   kind: "foreignKey",
   columns: normalizeColumnList(columns),
   references: () => ({
-    tableName: target()[TypeId4].baseName,
-    schemaName: target()[TypeId4].schemaName,
+    tableName: target()[TypeId6].baseName,
+    schemaName: target()[TypeId6].schemaName,
+    casing: target()[TypeId6].casing,
     columns: normalizeColumnList(referencedColumns),
-    knownColumns: Object.keys(target()[TypeId4].fields)
+    knownColumns: Object.keys(target()[TypeId6].fields).map((key) => key)
   })
 });
 var check = (name, predicate) => makeOption({
@@ -672,66 +776,34 @@ var check = (name, predicate) => makeOption({
   predicate
 });
 
-// src/internal/schema-expression.ts
-import { parse, toSql } from "pgsql-ast-parser";
-import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
-var TypeId5 = Symbol.for("effect-qb/SchemaExpression");
-var SchemaExpressionProto = {
-  pipe() {
-    return pipeArguments3(this, arguments);
-  }
-};
-var attachPipe3 = (value) => {
-  Object.defineProperty(value, "pipe", {
-    configurable: true,
-    writable: true,
-    value: function() {
-      return pipeArguments3(value, arguments);
-    }
-  });
-  return value;
+// src/internal/sql-expression-renderer.ts
+var renderQueryAst = (ast, state, dialect) => {
+  return dialect.renderQueryAst(ast, state, dialect);
 };
-var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId5 in value);
-var fromAst = (ast) => {
-  const expression = attachPipe3(Object.create(SchemaExpressionProto));
-  expression[TypeId5] = {
-    ast
-  };
-  return expression;
+var renderExpression = (expression, state, dialect) => {
+  return dialect.renderExpression(expression, state, dialect);
 };
-var fromSql = (sql) => {
-  const expression = attachPipe3(Object.create(SchemaExpressionProto));
-  expression[TypeId5] = {
-    sql: sql.trim()
-  };
-  return expression;
+
+// src/postgres/internal/schema-ddl.ts
+import { parse as parse2, toSql as toSql2 } from "pgsql-ast-parser";
+
+// src/internal/dialect.ts
+var quoteDoubleQuotedIdentifier = (value) => {
+  return `"${value.replaceAll('"', '""')}"`;
 };
-var parseExpression = (sql) => fromAst(parse(sql, "expr"));
-var toAst = (expression) => {
-  const ast = expression[TypeId5].ast;
-  if (ast !== undefined) {
-    return ast;
-  }
-  return parse(render(expression), "expr");
+var quoteBacktickIdentifier = (value) => {
+  return `\`${value.replaceAll("`", "``")}\``;
 };
-var render = (expression) => expression[TypeId5].sql ?? toSql.expr(toAst(expression));
-var normalize = (expression) => (() => {
-  const sql = render(expression);
-  try {
-    return parseExpression(sql);
-  } catch {
-    return fromSql(sql);
-  }
-})();
+var renderDbTypeName = (value) => value;
 
-// src/postgres/internal/sql-expression-renderer.ts
+// src/internal/dialect-renderers/postgres.ts
 import * as Schema5 from "effect/Schema";
 
 // src/internal/query.ts
 import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
 
 // src/internal/query-ast.ts
-var TypeId6 = Symbol.for("effect-qb/QueryAst");
+var TypeId7 = Symbol.for("effect-qb/QueryAst");
 
 // src/internal/predicate/runtime.ts
 var trueFormula = () => ({ kind: "true" });
@@ -1080,6 +1152,9 @@ var valueKeyOfLiteral = (value) => {
     return "null";
   }
   if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw new Error("Expected a valid Date value");
+    }
     return `date:${value.toISOString()}`;
   }
   return "unknown";
@@ -1415,7 +1490,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
     }
   });
   plan[TypeId] = state;
-  plan[TypeId6] = ast;
+  plan[TypeId7] = ast;
   plan[QueryTypeId] = {
     required: undefined,
     availableNames: undefined,
@@ -1429,7 +1504,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
   };
   return plan;
 };
-var getAst = (plan) => plan[TypeId6];
+var getAst = (plan) => plan[TypeId7];
 var getQueryState = (plan) => plan[QueryTypeId];
 var extractRequiredRuntime = (selection) => {
   const required = new Set;
@@ -1448,22 +1523,14 @@ var extractRequiredRuntime = (selection) => {
   return [...required];
 };
 var extractSingleSelectedExpressionRuntime = (selection) => {
-  const keys = Object.keys(selection);
-  if (keys.length !== 1) {
-    throw new Error("scalar subqueries must select exactly one top-level expression");
-  }
   const record = selection;
-  const value = record[keys[0]];
-  if (value === null || typeof value !== "object" || !(TypeId2 in value)) {
-    throw new Error("scalar subqueries must select a scalar expression");
-  }
-  return value;
+  return record[Object.keys(record)[0]];
 };
 var currentRequiredList = (required) => Array.isArray(required) ? [...required] : required === undefined ? [] : [required];
 
 // src/internal/json/path.ts
 var SegmentTypeId = Symbol.for("effect-qb/JsonPathSegment");
-var TypeId7 = Symbol.for("effect-qb/JsonPath");
+var TypeId8 = Symbol.for("effect-qb/JsonPath");
 var makeSegment = (segment) => segment;
 var key = (value) => makeSegment({
   [SegmentTypeId]: {
@@ -1500,105 +1567,23 @@ var descend = () => makeSegment({
   kind: "descend"
 });
 var path = (...segments) => ({
-  [TypeId7]: {
+  [TypeId8]: {
     segments
   },
   segments
 });
 
 // src/internal/dsl-plan-runtime.ts
-var renderSelectLockMode = (mode) => {
-  switch (mode) {
-    case "update":
-      return "for update";
-    case "share":
-      return "for share";
-  }
-  throw new Error("lock(...) mode must be update or share for select statements");
-};
-var renderMysqlMutationLockMode = (mode, statement) => {
-  switch (mode) {
-    case "lowPriority":
-      return " low_priority";
-    case "ignore":
-      return " ignore";
-    case "quick":
-      if (statement === "delete") {
-        return " quick";
-      }
-      break;
+var renderSelectLockMode = (mode) => mode === "update" ? "for update" : "for share";
+var renderMysqlMutationLockMode = (mode, _statement) => {
+  if (mode === "lowPriority") {
+    return " low_priority";
   }
-  throw new Error(statement === "update" ? "lock(...) mode must be lowPriority or ignore for update statements" : "lock(...) mode must be lowPriority, quick, or ignore for delete statements");
+  return mode === "ignore" ? " ignore" : " quick";
 };
 var makeDslPlanRuntime = (ctx) => {
-  const aliasedSourceKinds = new Set(["derived", "cte", "lateral", "values", "unnest", "tableFunction"]);
-  const isRecord = (value) => typeof value === "object" && value !== null;
-  const isPlan = (value) => isRecord(value) && (TypeId in value);
-  const hasColumnRecord = (value) => isRecord(value.columns);
   const sourceRequiredList = (source) => typeof source === "object" && source !== null && ("required" in source) ? ctx.currentRequiredList(source.required) : [];
-  const isAliasedSource = (source) => {
-    if (!isRecord(source)) {
-      return false;
-    }
-    if (TypeId4 in source) {
-      return true;
-    }
-    if (!("kind" in source) || !("name" in source) || !("baseName" in source)) {
-      return false;
-    }
-    if (typeof source.kind !== "string" || !aliasedSourceKinds.has(source.kind)) {
-      return false;
-    }
-    if (typeof source.name !== "string" || typeof source.baseName !== "string") {
-      return false;
-    }
-    switch (source.kind) {
-      case "derived":
-      case "cte":
-      case "lateral":
-        return isPlan(source.plan) && hasColumnRecord(source);
-      case "values":
-        return Array.isArray(source.rows) && hasColumnRecord(source);
-      case "unnest":
-        return isRecord(source.arrays) && hasColumnRecord(source);
-      case "tableFunction":
-        return typeof source.functionName === "string" && Array.isArray(source.args) && hasColumnRecord(source);
-    }
-    return false;
-  };
-  const assertAliasedSource = (source, message) => {
-    if (!isAliasedSource(source)) {
-      throw new Error(message);
-    }
-  };
-  const assertPlanComplete = (plan) => {
-    const required = ctx.currentRequiredList(plan[TypeId].required);
-    if (required.length > 0) {
-      throw new Error(`query references sources that are not yet in scope: ${required.join(", ")}`);
-    }
-  };
-  const assertSourceNameAvailable = (available, sourceName) => {
-    if (sourceName in available) {
-      throw new Error(`query source name is already in scope: ${sourceName}`);
-    }
-  };
-  const assertSelectHasBaseSourceForJoin = (statement, available) => {
-    if (statement === "select" && Object.keys(available).length === 0) {
-      throw new Error("select joins require a from(...) source before joining");
-    }
-  };
-  const supportsJoinSources = (statement) => statement === "select" || statement === "update" || statement === "delete";
-  const assertSetOperandStatement = (plan) => {
-    const statement = ctx.getQueryState(plan).statement;
-    if (statement !== "select" && statement !== "set") {
-      throw new Error("set operator operands only accept select-like query plans");
-    }
-  };
   const buildSetOperation = (kind, all, left, right) => {
-    assertSetOperandStatement(left);
-    assertSetOperandStatement(right);
-    assertPlanComplete(left);
-    assertPlanComplete(right);
     const leftState = left[TypeId];
     const leftAst = ctx.getAst(left);
     const basePlan = leftAst.kind === "set" ? leftAst.setBase ?? left : left;
@@ -1653,15 +1638,10 @@ var makeDslPlanRuntime = (ctx) => {
     if (currentQuery.statement === "insert") {
       return ctx.attachInsertSource(plan, source);
     }
-    assertAliasedSource(source, "from(...) requires an aliased source in select/update statements");
-    if (currentQuery.statement === "select" && currentAst.from !== undefined) {
-      throw new Error("select statements accept only one from(...) source; use joins for additional sources");
-    }
     const sourceLike = source;
     const { sourceName, sourceBaseName } = ctx.sourceDetails(sourceLike);
     const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(sourceLike);
     const sourceRequired = sourceRequiredList(sourceLike);
-    assertSourceNameAvailable(current.available, sourceName);
     if (currentQuery.statement === "select") {
       const nextAvailable = {
         [sourceName]: {
@@ -1716,7 +1696,7 @@ var makeDslPlanRuntime = (ctx) => {
         ]
       }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
     }
-    throw new Error(`from(...) is not supported for ${currentQuery.statement} statements`);
+    return plan;
   };
   const having = (predicate) => (plan) => {
     const current = plan[TypeId];
@@ -1741,16 +1721,9 @@ var makeDslPlanRuntime = (ctx) => {
     const current = plan[TypeId];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
-    if (supportsJoinSources(currentQuery.statement)) {
-      assertAliasedSource(table, "join(...) requires an aliased source in select/update/delete statements");
-      assertSelectHasBaseSourceForJoin(currentQuery.statement, current.available);
-    }
     const { sourceName, sourceBaseName } = ctx.sourceDetails(table);
     const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table);
     const sourceRequired = sourceRequiredList(table);
-    if (supportsJoinSources(currentQuery.statement)) {
-      assertSourceNameAvailable(current.available, sourceName);
-    }
     const nextAvailable = {
       ...current.available,
       [sourceName]: {
@@ -1782,16 +1755,9 @@ var makeDslPlanRuntime = (ctx) => {
     const currentQuery = ctx.getQueryState(plan);
     const onExpression = ctx.toDialectExpression(on);
     const onFormula = ctx.formulaOfExpressionRuntime(onExpression);
-    if (supportsJoinSources(currentQuery.statement)) {
-      assertAliasedSource(table, "join(...) requires an aliased source in select/update/delete statements");
-      assertSelectHasBaseSourceForJoin(currentQuery.statement, current.available);
-    }
     const { sourceName, sourceBaseName } = ctx.sourceDetails(table);
     const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table);
     const sourceRequired = sourceRequiredList(table);
-    if (supportsJoinSources(currentQuery.statement)) {
-      assertSourceNameAvailable(current.available, sourceName);
-    }
     const baseAvailable = kind === "right" || kind === "full" ? Object.fromEntries(Object.entries(current.available).map(([name, source]) => [name, {
       name: source.name,
       mode: "optional",
@@ -1826,9 +1792,6 @@ var makeDslPlanRuntime = (ctx) => {
     }, kind === "inner" ? ctx.assumeFormulaTrue(currentQuery.assumptions, onFormula) : currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
   };
   const orderBy = (value, direction = "asc") => (plan) => {
-    if (direction !== "asc" && direction !== "desc") {
-      throw new Error("orderBy(...) direction must be asc or desc");
-    }
     const current = plan[TypeId];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
@@ -1852,15 +1815,6 @@ var makeDslPlanRuntime = (ctx) => {
     const current = plan[TypeId];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
-    if (currentQuery.statement === "select") {
-      renderSelectLockMode(mode);
-    }
-    if (ctx.profile.dialect === "mysql" && currentQuery.statement === "update") {
-      renderMysqlMutationLockMode(mode, "update");
-    }
-    if (ctx.profile.dialect === "mysql" && currentQuery.statement === "delete") {
-      renderMysqlMutationLockMode(mode, "delete");
-    }
     return ctx.makePlan({
       selection: current.selection,
       required: current.required,
@@ -1937,113 +1891,272 @@ var makeDslPlanRuntime = (ctx) => {
   };
 };
 
-// src/internal/dsl-mutation-runtime.ts
-var expectInsertSourceKind = (source) => {
-  if (source !== undefined && source.kind !== "values" && source.kind !== "query" && source.kind !== "unnest") {
-    throw new Error("Unsupported insert source kind");
-  }
-  return source;
-};
-var expectConflictClause = (conflict) => {
-  if (conflict === undefined) {
-    return conflict;
-  }
-  if (conflict.kind !== "conflict") {
-    throw new Error("Unsupported conflict clause kind");
-  }
-  if (conflict.action !== "doNothing" && conflict.action !== "doUpdate") {
-    throw new Error("Unsupported conflict action");
-  }
-  if (conflict.target !== undefined && conflict.target.kind !== "columns" && conflict.target.kind !== "constraint") {
-    throw new Error("Unsupported conflict target kind");
+// src/internal/dsl-transaction-ddl-runtime.ts
+var renderTransactionIsolationLevel = (isolationLevel) => {
+  if (isolationLevel === undefined) {
+    return "";
   }
-  return conflict;
+  return `isolation level ${isolationLevel}`;
 };
-var makeDslMutationRuntime = (ctx) => {
-  const aliasedSourceKinds = new Set(["derived", "cte", "lateral", "values", "unnest", "tableFunction"]);
-  const isRecord = (value) => typeof value === "object" && value !== null;
-  const isTableTarget = (target) => typeof target === "object" && target !== null && (TypeId4 in target) && (TypeId in target);
-  const hasColumnRecord = (value) => isRecord(value.columns);
-  const isAliasedSource = (source) => {
-    if (!isRecord(source)) {
-      return false;
-    }
-    if (isTableTarget(source)) {
-      return true;
-    }
-    if (!("kind" in source) || !("name" in source) || !("baseName" in source)) {
-      return false;
-    }
-    if (typeof source.kind !== "string" || !aliasedSourceKinds.has(source.kind)) {
-      return false;
-    }
-    if (typeof source.name !== "string" || typeof source.baseName !== "string") {
-      return false;
-    }
-    switch (source.kind) {
-      case "derived":
-      case "cte":
-      case "lateral":
-        return isRecord(source.plan) && TypeId in source.plan && hasColumnRecord(source);
-      case "values":
-        return Array.isArray(source.rows) && hasColumnRecord(source);
-      case "unnest":
-        return isRecord(source.arrays) && hasColumnRecord(source);
-      case "tableFunction":
-        return typeof source.functionName === "string" && Array.isArray(source.args) && hasColumnRecord(source);
-    }
-    return false;
+var expectDdlClauseKind = (ddl, _kind) => ddl;
+var expectTruncateClause = (truncate) => truncate;
+var normalizeStatementFlag = (value) => value ?? false;
+var normalizeStatementIdentifier = (_apiName, _identifierName, value) => value;
+var makeDslTransactionDdlRuntime = (ctx) => {
+  const transaction = (options2 = {}) => {
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "transaction",
+      select: {},
+      transaction: {
+        kind: "transaction",
+        isolationLevel: options2.isolationLevel,
+        readOnly: options2.readOnly
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "transaction");
   };
-  const assertMutationTarget = (target, apiName) => {
-    if (!isTableTarget(target)) {
-      throw new Error(`${apiName}(...) requires table targets`);
-    }
+  const commit = () => ctx.makePlan({
+    selection: {},
+    required: [],
+    available: {},
+    dialect: ctx.profile.dialect
+  }, {
+    kind: "commit",
+    select: {},
+    transaction: {
+      kind: "commit"
+    },
+    where: [],
+    having: [],
+    joins: [],
+    groupBy: [],
+    orderBy: []
+  }, undefined, "transaction", "commit");
+  const rollback = () => ctx.makePlan({
+    selection: {},
+    required: [],
+    available: {},
+    dialect: ctx.profile.dialect
+  }, {
+    kind: "rollback",
+    select: {},
+    transaction: {
+      kind: "rollback"
+    },
+    where: [],
+    having: [],
+    joins: [],
+    groupBy: [],
+    orderBy: []
+  }, undefined, "transaction", "rollback");
+  const savepoint = (name) => {
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "savepoint",
+      select: {},
+      transaction: {
+        kind: "savepoint",
+        name
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "savepoint");
   };
-  const assertAliasedSource = (source, apiName) => {
-    if (!isAliasedSource(source)) {
-      throw new Error(`${apiName}(...) requires an aliased source`);
-    }
+  const rollbackTo = (name) => {
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "rollbackTo",
+      select: {},
+      transaction: {
+        kind: "rollbackTo",
+        name
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "rollbackTo");
   };
-  const assertMutationTargets = (target, apiName, options2 = {}) => {
-    const targets = Array.isArray(target) ? target : [target];
-    if (targets.length === 0) {
-      throw new Error(`${apiName}(...) requires at least one table target`);
-    }
-    if (Array.isArray(target) && targets.length === 1) {
-      throw new Error(`${apiName}(...) requires a table target, not a single-element target tuple`);
-    }
-    for (const entry of targets) {
-      assertMutationTarget(entry, apiName);
-    }
-    if (targets.length > 1 && options2.allowMultiple !== true) {
-      throw new Error(`${apiName}(...) requires a single table target`);
-    }
-    if (targets.length > 1 && ctx.profile.dialect !== "mysql" && ctx.profile.dialect !== "sqlite") {
-      throw new Error(`${apiName}(...) only supports multiple mutation targets for mysql`);
-    }
+  const releaseSavepoint = (name) => {
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: ctx.profile.dialect
+    }, {
+      kind: "releaseSavepoint",
+      select: {},
+      transaction: {
+        kind: "releaseSavepoint",
+        name
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "transaction", "releaseSavepoint");
   };
-  const assertUniqueTargetNames = (targets) => {
-    const seen = new Set;
-    for (const target of targets) {
-      if (seen.has(target.tableName)) {
-        throw new Error(`mutation target source names must be unique: ${target.tableName}`);
-      }
-      seen.add(target.tableName);
-    }
+  const createTable = (target, options2 = {}) => {
+    const ifNotExists = normalizeStatementFlag(options2.ifNotExists);
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "createTable",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "createTable",
+        ifNotExists
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "createTable");
   };
-  const assertInsertSelectSource = (sourcePlan, selection) => {
-    const statement = ctx.getQueryState(sourcePlan).statement;
-    if (statement !== "select" && statement !== "set") {
-      throw new Error("insert sources only accept select-like query plans");
-    }
-    for (const value of Object.values(selection)) {
-      if (value === null || typeof value !== "object" || !(TypeId2 in value)) {
-        throw new Error("insert sources require a flat selection object");
-      }
-    }
+  const dropTable = (target, options2 = {}) => {
+    const ifExists = normalizeStatementFlag(options2.ifExists);
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "dropTable",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "dropTable",
+        ifExists
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "dropTable");
+  };
+  const createIndex = (target, columns, options2 = {}) => {
+    const normalizedColumns = ctx.normalizeColumnList(columns);
+    const unique2 = normalizeStatementFlag(options2.unique);
+    const ifNotExists = normalizeStatementFlag(options2.ifNotExists);
+    const name = options2.name;
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "createIndex",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "createIndex",
+        name: name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, unique2),
+        columns: normalizedColumns,
+        unique: unique2,
+        ifNotExists
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "createIndex");
+  };
+  const dropIndex = (target, columns, options2 = {}) => {
+    const normalizedColumns = ctx.normalizeColumnList(columns);
+    const ifExists = normalizeStatementFlag(options2.ifExists);
+    const name = options2.name;
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "dropIndex",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      ddl: {
+        kind: "dropIndex",
+        name: name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
+        ifExists
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "ddl", "dropIndex");
+  };
+  return {
+    transaction,
+    commit,
+    rollback,
+    savepoint,
+    rollbackTo,
+    releaseSavepoint,
+    createTable,
+    dropTable,
+    createIndex,
+    dropIndex
   };
+};
+
+// src/internal/dsl-mutation-runtime.ts
+var expectConflictClause = (conflict) => conflict;
+var makeDslMutationRuntime = (ctx) => {
   const insert = (target, values) => {
-    assertMutationTargets(target, "insert");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     const assignments = values === undefined ? [] : ctx.buildMutationAssignments(target, values);
     const required = assignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies));
@@ -2119,7 +2232,6 @@ var makeDslMutationRuntime = (ctx) => {
     }
     const sourcePlan = source;
     const selection = sourcePlan[TypeId].selection;
-    assertInsertSelectSource(sourcePlan, selection);
     const columns = ctx.normalizeInsertSelectColumns(selection);
     return ctx.makePlan({
       selection: current.selection,
@@ -2140,15 +2252,13 @@ var makeDslMutationRuntime = (ctx) => {
     const current = plan[TypeId];
     const currentAst = ctx.getAst(plan);
     const currentQuery = ctx.getQueryState(plan);
-    if (currentQuery.statement !== "insert") {
-      throw new Error(`onConflict(...) is not supported for ${currentQuery.statement} statements`);
-    }
     const insertTarget = currentAst.into.source;
-    const conflictTarget = ctx.buildConflictTarget(insertTarget, target);
+    const conflictTarget = expectConflictClause({
+      kind: "conflict",
+      action: "doNothing",
+      target: ctx.buildConflictTarget(insertTarget, target)
+    }).target;
     const updateAssignments = options2.update ? ctx.buildMutationAssignments(insertTarget, options2.update) : [];
-    if (options2.update !== undefined && updateAssignments.length === 0) {
-      throw new Error("conflict update assignments require at least one assignment");
-    }
     const updateWhere = options2.where === undefined ? undefined : ctx.toDialectExpression(options2.where);
     const targetWhere = conflictTarget.kind === "columns" ? conflictTarget.where : undefined;
     const required = [
@@ -2174,9 +2284,7 @@ var makeDslMutationRuntime = (ctx) => {
     }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, currentQuery.insertSource);
   };
   const update = (target, values) => {
-    assertMutationTargets(target, "update", { allowMultiple: true });
     const targets = ctx.mutationTargetClauses(target);
-    assertUniqueTargetNames(targets);
     const primaryTarget = targets[0];
     const assignments = ctx.buildMutationAssignments(target, values);
     const targetNames = new Set(targets.map((entry) => entry.tableName));
@@ -2200,13 +2308,9 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "update");
   };
   const upsert = (target, values, conflictColumns, updateValues) => {
-    assertMutationTargets(target, "upsert");
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     const assignments = ctx.buildMutationAssignments(target, values);
     const updateAssignments = updateValues ? ctx.buildMutationAssignments(target, updateValues) : [];
-    if (updateValues !== undefined && updateAssignments.length === 0) {
-      throw new Error("upsert update assignments require at least one assignment");
-    }
     const required = [
       ...assignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)),
       ...updateAssignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies))
@@ -2249,9 +2353,7 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "insert", target, "ready");
   };
   const delete_ = (target) => {
-    assertMutationTargets(target, "delete", { allowMultiple: true });
     const targets = ctx.mutationTargetClauses(target);
-    assertUniqueTargetNames(targets);
     const primaryTarget = targets[0];
     return ctx.makePlan({
       selection: {},
@@ -2271,7 +2373,8 @@ var makeDslMutationRuntime = (ctx) => {
     }, undefined, "write", "delete");
   };
   const truncate = (target, options2 = {}) => {
-    assertMutationTargets(target, "truncate");
+    const restartIdentity = normalizeStatementFlag(options2.restartIdentity);
+    const cascade = normalizeStatementFlag(options2.cascade);
     const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
     return ctx.makePlan({
       selection: {},
@@ -2289,8 +2392,8 @@ var makeDslMutationRuntime = (ctx) => {
       },
       truncate: {
         kind: "truncate",
-        restartIdentity: options2.restartIdentity ?? false,
-        cascade: options2.cascade ?? false
+        restartIdentity,
+        cascade
       },
       where: [],
       having: [],
@@ -2299,20 +2402,12 @@ var makeDslMutationRuntime = (ctx) => {
       orderBy: []
     }, undefined, "write", "truncate");
   };
-  const merge = (target, source, on, options2 = {}) => {
-    assertMutationTargets(target, "merge");
-    assertAliasedSource(source, "merge");
+  const merge2 = (target, source, on, options2 = {}) => {
     const { sourceName: targetName, sourceBaseName: targetBaseName } = ctx.targetSourceDetails(target);
     const { sourceName: usingName, sourceBaseName: usingBaseName } = ctx.sourceDetails(source);
-    if (targetName === usingName) {
-      throw new Error(`merge(...) source name must differ from target source name: ${targetName}`);
-    }
     const onExpression = ctx.toDialectExpression(on);
     const matched = options2.whenMatched;
     const notMatched = options2.whenNotMatched;
-    if (matched && "delete" in matched && "update" in matched) {
-      throw new Error("merge whenMatched cannot specify both update and delete");
-    }
     const matchedPredicate = matched?.predicate ? ctx.toDialectExpression(matched.predicate) : undefined;
     const matchedAssignments = matched && "update" in matched && matched.update ? ctx.buildMutationAssignments(target, matched.update) : [];
     const notMatchedPredicate = notMatched?.predicate ? ctx.toDialectExpression(notMatched.predicate) : undefined;
@@ -2377,305 +2472,17 @@ var makeDslMutationRuntime = (ctx) => {
       joins: [],
       groupBy: [],
       orderBy: []
-    }, undefined, "write", "merge");
-  };
-  return {
-    insert,
-    attachInsertSource,
-    onConflict,
-    update,
-    upsert,
-    delete_,
-    truncate,
-    merge
-  };
-};
-
-// src/internal/dsl-transaction-ddl-runtime.ts
-var allowedIsolationLevels = new Set(["read committed", "repeatable read", "serializable"]);
-var renderTransactionIsolationLevel = (isolationLevel) => {
-  if (isolationLevel === undefined) {
-    return "";
-  }
-  if (typeof isolationLevel !== "string" || !allowedIsolationLevels.has(isolationLevel)) {
-    throw new Error("Unsupported transaction isolation level");
-  }
-  return `isolation level ${isolationLevel}`;
-};
-var expectDdlClauseKind = (ddl, kind) => {
-  if (ddl === undefined || ddl.kind !== kind) {
-    throw new Error("Unsupported DDL statement kind");
-  }
-  return ddl;
-};
-var expectTruncateClause = (truncate) => {
-  if (truncate === undefined || truncate.kind !== "truncate") {
-    throw new Error("Unsupported truncate statement kind");
-  }
-  return truncate;
-};
-var validateIsolationLevel = (isolationLevel) => {
-  renderTransactionIsolationLevel(isolationLevel);
-};
-var makeDslTransactionDdlRuntime = (ctx) => {
-  const isRecord = (value) => typeof value === "object" && value !== null;
-  const assertTableTarget = (target, apiName) => {
-    if (!isRecord(target) || !(TypeId4 in target) || !(TypeId in target)) {
-      throw new Error(`${apiName}(...) requires a table target`);
-    }
-  };
-  const validateIndexColumns = (target, columns) => {
-    const fields = target[TypeId4]?.fields;
-    if (fields === undefined) {
-      return;
-    }
-    for (const columnName of columns) {
-      if (!(columnName in fields)) {
-        throw new Error(`effect-qb: unknown index column '${columnName}'`);
-      }
-    }
-  };
-  const transaction = (options2 = {}) => {
-    validateIsolationLevel(options2.isolationLevel);
-    return ctx.makePlan({
-      selection: {},
-      required: [],
-      available: {},
-      dialect: ctx.profile.dialect
-    }, {
-      kind: "transaction",
-      select: {},
-      transaction: {
-        kind: "transaction",
-        isolationLevel: options2.isolationLevel,
-        readOnly: options2.readOnly
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined, "transaction", "transaction");
-  };
-  const commit = () => ctx.makePlan({
-    selection: {},
-    required: [],
-    available: {},
-    dialect: ctx.profile.dialect
-  }, {
-    kind: "commit",
-    select: {},
-    transaction: {
-      kind: "commit"
-    },
-    where: [],
-    having: [],
-    joins: [],
-    groupBy: [],
-    orderBy: []
-  }, undefined, "transaction", "commit");
-  const rollback = () => ctx.makePlan({
-    selection: {},
-    required: [],
-    available: {},
-    dialect: ctx.profile.dialect
-  }, {
-    kind: "rollback",
-    select: {},
-    transaction: {
-      kind: "rollback"
-    },
-    where: [],
-    having: [],
-    joins: [],
-    groupBy: [],
-    orderBy: []
-  }, undefined, "transaction", "rollback");
-  const savepoint = (name) => ctx.makePlan({
-    selection: {},
-    required: [],
-    available: {},
-    dialect: ctx.profile.dialect
-  }, {
-    kind: "savepoint",
-    select: {},
-    transaction: {
-      kind: "savepoint",
-      name
-    },
-    where: [],
-    having: [],
-    joins: [],
-    groupBy: [],
-    orderBy: []
-  }, undefined, "transaction", "savepoint");
-  const rollbackTo = (name) => ctx.makePlan({
-    selection: {},
-    required: [],
-    available: {},
-    dialect: ctx.profile.dialect
-  }, {
-    kind: "rollbackTo",
-    select: {},
-    transaction: {
-      kind: "rollbackTo",
-      name
-    },
-    where: [],
-    having: [],
-    joins: [],
-    groupBy: [],
-    orderBy: []
-  }, undefined, "transaction", "rollbackTo");
-  const releaseSavepoint = (name) => ctx.makePlan({
-    selection: {},
-    required: [],
-    available: {},
-    dialect: ctx.profile.dialect
-  }, {
-    kind: "releaseSavepoint",
-    select: {},
-    transaction: {
-      kind: "releaseSavepoint",
-      name
-    },
-    where: [],
-    having: [],
-    joins: [],
-    groupBy: [],
-    orderBy: []
-  }, undefined, "transaction", "releaseSavepoint");
-  const createTable = (target, options2 = {}) => {
-    assertTableTarget(target, "createTable");
-    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
-    return ctx.makePlan({
-      selection: {},
-      required: [],
-      available: {},
-      dialect: target[TypeId].dialect
-    }, {
-      kind: "createTable",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      ddl: {
-        kind: "createTable",
-        ifNotExists: options2.ifNotExists ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined, "ddl", "createTable");
-  };
-  const dropTable = (target, options2 = {}) => {
-    assertTableTarget(target, "dropTable");
-    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
-    return ctx.makePlan({
-      selection: {},
-      required: [],
-      available: {},
-      dialect: target[TypeId].dialect
-    }, {
-      kind: "dropTable",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      ddl: {
-        kind: "dropTable",
-        ifExists: options2.ifExists ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined, "ddl", "dropTable");
-  };
-  const createIndex = (target, columns, options2 = {}) => {
-    assertTableTarget(target, "createIndex");
-    const normalizedColumns = ctx.normalizeColumnList(columns);
-    validateIndexColumns(target, normalizedColumns);
-    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
-    return ctx.makePlan({
-      selection: {},
-      required: [],
-      available: {},
-      dialect: target[TypeId].dialect
-    }, {
-      kind: "createIndex",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      ddl: {
-        kind: "createIndex",
-        name: options2.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, options2.unique ?? false),
-        columns: normalizedColumns,
-        unique: options2.unique ?? false,
-        ifNotExists: options2.ifNotExists ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined, "ddl", "createIndex");
-  };
-  const dropIndex = (target, columns, options2 = {}) => {
-    assertTableTarget(target, "dropIndex");
-    const normalizedColumns = ctx.normalizeColumnList(columns);
-    validateIndexColumns(target, normalizedColumns);
-    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
-    return ctx.makePlan({
-      selection: {},
-      required: [],
-      available: {},
-      dialect: target[TypeId].dialect
-    }, {
-      kind: "dropIndex",
-      select: {},
-      target: {
-        kind: "from",
-        tableName: sourceName,
-        baseTableName: sourceBaseName,
-        source: target
-      },
-      ddl: {
-        kind: "dropIndex",
-        name: options2.name ?? ctx.defaultIndexName(sourceBaseName, normalizedColumns, false),
-        ifExists: options2.ifExists ?? false
-      },
-      where: [],
-      having: [],
-      joins: [],
-      groupBy: [],
-      orderBy: []
-    }, undefined, "ddl", "dropIndex");
-  };
-  return {
-    transaction,
-    commit,
-    rollback,
-    savepoint,
-    rollbackTo,
-    releaseSavepoint,
-    createTable,
-    dropTable,
-    createIndex,
-    dropIndex
+    }, undefined, "write", "merge");
+  };
+  return {
+    insert,
+    attachInsertSource,
+    onConflict,
+    update,
+    upsert,
+    delete_,
+    truncate,
+    merge: merge2
   };
 };
 
@@ -2799,6 +2606,12 @@ var isPlainRecord = (value) => {
   return prototype === Object.prototype || prototype === null;
 };
 var pad = (value, width = 2) => value.toString().padStart(width, "0");
+var validDate = (value) => {
+  if (Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value");
+  }
+  return value;
+};
 var formatLocalDate = (value) => `${pad(value.getUTCFullYear(), 4)}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`;
 var formatLocalTime = (value) => {
   const milliseconds = value.getUTCMilliseconds();
@@ -2886,7 +2699,7 @@ var normalizeDecimalString = (value) => {
 };
 var normalizeLocalDate = (value) => {
   if (value instanceof Date) {
-    return formatLocalDate(value);
+    return formatLocalDate(validDate(value));
   }
   const raw = expectString(value, "local date").trim();
   if (isValidLocalDateString(raw)) {
@@ -2903,7 +2716,7 @@ var normalizeLocalDate = (value) => {
 };
 var normalizeLocalTime = (value) => {
   if (value instanceof Date) {
-    return formatLocalTime(value);
+    return formatLocalTime(validDate(value));
   }
   const raw = expectString(value, "local time").trim();
   if (isValidLocalTimeString(raw)) {
@@ -2913,7 +2726,7 @@ var normalizeLocalTime = (value) => {
 };
 var normalizeOffsetTime = (value) => {
   if (value instanceof Date) {
-    return `${formatLocalTime(value)}Z`;
+    return `${formatLocalTime(validDate(value))}Z`;
   }
   const raw = expectString(value, "offset time").trim();
   if (isValidOffsetTimeString(raw)) {
@@ -2923,7 +2736,7 @@ var normalizeOffsetTime = (value) => {
 };
 var normalizeLocalDateTime = (value) => {
   if (value instanceof Date) {
-    return formatLocalDateTime(value);
+    return formatLocalDateTime(validDate(value));
   }
   const raw = expectString(value, "local datetime").trim();
   const canonicalLocalDateTime = raw.replace(" ", "T");
@@ -2941,7 +2754,7 @@ var normalizeLocalDateTime = (value) => {
 };
 var normalizeInstant = (value) => {
   if (value instanceof Date) {
-    return value.toISOString();
+    return validDate(value).toISOString();
   }
   const raw = expectString(value, "instant").trim();
   if (!/[zZ]|[+-]\d{2}:\d{2}$/.test(raw)) {
@@ -3157,16 +2970,16 @@ var isJsonDbType = (dbType) => {
   const variant = dbType.variant;
   return variant === "json" || variant === "jsonb";
 };
-var schemaAccepts = (schema2, value) => schema2 !== undefined && Schema4.is(schema2)(value);
-var encodeWithSchema = (schema2, value) => {
-  if (schema2 === undefined) {
+var schemaAccepts = (schema, value) => schema !== undefined && Schema4.is(schema)(value);
+var encodeWithSchema = (schema, value) => {
+  if (schema === undefined) {
     return { value, encoded: false };
   }
-  if (!Schema4.is(schema2)(value)) {
+  if (!Schema4.is(schema)(value)) {
     return { value, encoded: false };
   }
   return {
-    value: Schema4.encodeUnknownSync(schema2)(value),
+    value: Schema4.encodeUnknownSync(schema)(value),
     encoded: true
   };
 };
@@ -3262,12 +3075,12 @@ var renderJsonSelectSql = (sql, context) => {
 };
 
 // src/internal/projection-alias.ts
-var TypeId8 = Symbol.for("effect-qb/ProjectionAlias");
+var TypeId9 = Symbol.for("effect-qb/ProjectionAlias");
 
 // src/internal/projections.ts
 var aliasFromPath = (path2) => path2.join("__");
 var isExpression = (value) => typeof value === "object" && value !== null && (TypeId2 in value);
-var projectionAliasOf = (expression) => (TypeId8 in expression) ? expression[TypeId8].alias : undefined;
+var projectionAliasOf = (expression) => (TypeId9 in expression) ? expression[TypeId9].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]);
@@ -3329,7 +3142,7 @@ var subqueryPlanGroupingKey = (plan) => {
 };
 var literalGroupingKey = (value) => {
   if (value instanceof Date) {
-    return `date:${value.toISOString()}`;
+    return Number.isNaN(value.getTime()) ? "date:invalid" : `date:${value.toISOString()}`;
   }
   if (value === null) {
     return "null";
@@ -3347,7 +3160,27 @@ var literalGroupingKey = (value) => {
 };
 var isExpression2 = (value) => value !== null && typeof value === "object" && (TypeId2 in value);
 var expressionGroupingKey = (value) => isExpression2(value) ? groupingKeyOfExpression(value) : "missing";
+var requiredExpressionGroupingKey = (_functionName, value) => groupingKeyOfExpression(value);
+var requiredBinaryExpressionGroupingKey = (_functionName, left, right) => `${groupingKeyOfExpression(left)},${groupingKeyOfExpression(right)}`;
+var functionCallArgsGroupingKey = (args) => args.map(groupingKeyOfExpression).join(",");
+var variadicGroupingKey = (_functionName, values) => values.map(groupingKeyOfExpression).join(",");
+var castTargetGroupingKey = (target) => {
+  const typed = target;
+  return `${typed?.dialect}:${typed?.kind}`;
+};
 var escapeGroupingText = (value) => value.replace(/\\/g, "\\\\").replace(/,/g, "\\,").replace(/\|/g, "\\|").replace(/=/g, "\\=").replace(/>/g, "\\>");
+var functionCallNameGroupingKey = (name) => escapeGroupingText(name);
+var quantifiedComparisonGroupingName = (kind) => kind === "comparisonAny" ? "compareAny" : "compareAll";
+var caseGroupingKey = (branches, fallback) => {
+  const typedBranches = branches;
+  return `case(${typedBranches.map((branch) => `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(fallback)})`;
+};
+var collationGroupingKey = (collation) => {
+  if (Array.isArray(collation)) {
+    return collation.map((part) => escapeGroupingText(String(part))).join(",");
+  }
+  return escapeGroupingText(String(collation));
+};
 var jsonSegmentGroupingKey = (segment) => {
   if (segment !== null && typeof segment === "object" && "kind" in segment) {
     switch (segment.kind) {
@@ -3373,8 +3206,16 @@ var jsonSegmentGroupingKey = (segment) => {
   }
   return "unknown";
 };
-var jsonPathGroupingKey = (segments) => (segments ?? []).map(jsonSegmentGroupingKey).join(",");
-var isJsonPath = (value) => value !== null && typeof value === "object" && (TypeId7 in value);
+var jsonPathGroupingKey = (segments) => {
+  if (segments === undefined) {
+    return "";
+  }
+  if (!Array.isArray(segments)) {
+    return "unknown";
+  }
+  return segments.map(jsonSegmentGroupingKey).join(",");
+};
+var isJsonPath = (value) => value !== null && typeof value === "object" && (TypeId8 in value);
 var jsonOpaquePathGroupingKey = (value) => {
   if (isJsonPath(value)) {
     return `jsonpath:${jsonPathGroupingKey(value.segments)}`;
@@ -3387,7 +3228,16 @@ var jsonOpaquePathGroupingKey = (value) => {
   }
   return "jsonpath:unknown";
 };
-var jsonEntryGroupingKey = (entry) => `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`;
+var jsonKeysGroupingKey = (keys) => {
+  if (!Array.isArray(keys) || keys.length === 0) {
+    return "";
+  }
+  return keys.map((key2) => escapeGroupingText(String(key2))).join(",");
+};
+var jsonBuildObjectGroupingKey = (entries) => {
+  return entries.map((entry) => `${escapeGroupingText(entry.key)}=>${groupingKeyOfExpression(entry.value)}`).join("|");
+};
+var jsonBuildArrayGroupingKey = (values) => values.map(groupingKeyOfExpression).join(",");
 var groupingKeyOfExpression = (expression) => {
   const ast = expression[TypeId3];
   switch (ast.kind) {
@@ -3396,11 +3246,11 @@ var groupingKeyOfExpression = (expression) => {
     case "literal":
       return `literal:${literalGroupingKey(ast.value)}`;
     case "cast":
-      return `cast(${groupingKeyOfExpression(ast.value)} as ${ast.target.dialect}:${ast.target.kind})`;
+      return `cast(${requiredExpressionGroupingKey("cast", ast.value)} as ${castTargetGroupingKey(ast.target)})`;
     case "collate":
-      return `collate(${groupingKeyOfExpression(ast.value)},${ast.collation.map(escapeGroupingText).join(",")})`;
+      return `collate(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`;
     case "function":
-      return `function(${escapeGroupingText(ast.name)},${ast.args.map(groupingKeyOfExpression).join(",")})`;
+      return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`;
     case "isNull":
     case "isNotNull":
     case "not":
@@ -3409,7 +3259,7 @@ var groupingKeyOfExpression = (expression) => {
     case "count":
     case "max":
     case "min":
-      return `${ast.kind}(${groupingKeyOfExpression(ast.value)})`;
+      return `${ast.kind}(${requiredExpressionGroupingKey(ast.kind, ast.value)})`;
     case "eq":
     case "neq":
     case "lt":
@@ -3427,7 +3277,7 @@ var groupingKeyOfExpression = (expression) => {
     case "contains":
     case "containedBy":
     case "overlaps":
-      return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`;
+      return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`;
     case "and":
     case "or":
     case "coalesce":
@@ -3435,18 +3285,18 @@ var groupingKeyOfExpression = (expression) => {
     case "in":
     case "notIn":
     case "between":
-      return `${ast.kind}(${ast.values.map(groupingKeyOfExpression).join(",")})`;
+      return `${ast.kind}(${variadicGroupingKey(ast.kind, ast.values)})`;
     case "case":
-      return `case(${ast.branches.map((branch) => `when:${groupingKeyOfExpression(branch.when)}=>${groupingKeyOfExpression(branch.then)}`).join("|")};else:${groupingKeyOfExpression(ast.else)})`;
+      return caseGroupingKey(ast.branches, ast.else);
     case "exists":
       return `exists(${subqueryPlanGroupingKey(ast.plan)})`;
     case "scalarSubquery":
       return `scalarSubquery(${subqueryPlanGroupingKey(ast.plan)})`;
     case "inSubquery":
-      return `inSubquery(${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`;
+      return `inSubquery(${requiredExpressionGroupingKey("inSubquery", ast.left)},${subqueryPlanGroupingKey(ast.plan)})`;
     case "comparisonAny":
     case "comparisonAll":
-      return `${ast.kind}(${ast.operator},${groupingKeyOfExpression(ast.left)},${subqueryPlanGroupingKey(ast.plan)})`;
+      return `${ast.kind}(${ast.operator},${requiredExpressionGroupingKey(quantifiedComparisonGroupingName(ast.kind), ast.left)},${subqueryPlanGroupingKey(ast.plan)})`;
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
@@ -3460,7 +3310,7 @@ var groupingKeyOfExpression = (expression) => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys":
-      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${(ast.keys ?? []).map(escapeGroupingText).join(",")})`;
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonKeysGroupingKey(ast.keys)})`;
     case "jsonConcat":
     case "jsonMerge":
       return `json(${ast.kind},${expressionGroupingKey(ast.left)},${expressionGroupingKey(ast.right)},)`;
@@ -3476,9 +3326,9 @@ var groupingKeyOfExpression = (expression) => {
     case "jsonPathMatch":
       return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonOpaquePathGroupingKey(ast.query)})`;
     case "jsonBuildObject":
-      return `json(${ast.kind},${(ast.entries ?? []).map(jsonEntryGroupingKey).join("|")})`;
+      return `json(${ast.kind},${jsonBuildObjectGroupingKey(ast.entries)})`;
     case "jsonBuildArray":
-      return `json(${ast.kind},${(ast.values ?? []).map(groupingKeyOfExpression).join(",")})`;
+      return `json(${ast.kind},${jsonBuildArrayGroupingKey(ast.values)})`;
     case "jsonToJson":
     case "jsonToJsonb":
     case "jsonTypeOf":
@@ -3487,7 +3337,7 @@ var groupingKeyOfExpression = (expression) => {
     case "jsonStripNulls":
       return `json(${ast.kind},${expressionGroupingKey(ast.value)})`;
     default:
-      throw new Error("Unsupported expression for grouping key generation");
+      return `unknown:${typeof ast === "object" && ast !== null && "kind" in ast ? String(ast.kind) : "ast"}`;
   }
 };
 var dedupeGroupedExpressions = (values) => {
@@ -3502,51 +3352,20 @@ var dedupeGroupedExpressions = (values) => {
   });
 };
 
-// src/internal/aggregation-validation.ts
-var isExpression3 = (value) => typeof value === "object" && value !== null && (TypeId2 in value);
-var selectionHasAggregate = (selection) => {
-  if (isExpression3(selection)) {
-    return selection[TypeId2].kind === "aggregate";
-  }
-  return Object.values(selection).some((value) => selectionHasAggregate(value));
-};
-var isGroupedSelectionValid = (selection, groupedExpressions) => {
-  if (isExpression3(selection)) {
-    const aggregation = selection[TypeId2].kind;
-    if (aggregation === "aggregate") {
-      return true;
-    }
-    if (aggregation === "window") {
-      return false;
-    }
-    if (Object.keys(selection[TypeId2].dependencies).length === 0) {
-      return true;
-    }
-    return groupedExpressions.has(groupingKeyOfExpression(selection));
-  }
-  return Object.values(selection).every((value) => isGroupedSelectionValid(value, groupedExpressions));
-};
-var validateAggregationSelection = (selection, grouped) => {
-  const groupedExpressions = new Set(grouped.map(groupingKeyOfExpression));
-  const hasAggregate = selectionHasAggregate(selection);
-  const isValid = hasAggregate || grouped.length > 0 ? isGroupedSelectionValid(selection, groupedExpressions) : true;
-  if (!isValid) {
-    throw new Error("Invalid grouped selection: scalar expressions must be covered by groupBy(...) when aggregates are present");
-  }
-};
-
-// src/postgres/internal/sql-expression-renderer.ts
+// src/internal/dialect-renderers/postgres.ts
 var renderDbType = (dialect, dbType) => {
-  if (dialect.name === "mysql" && dbType.dialect === "mysql" && dbType.kind === "uuid") {
-    return "char(36)";
+  if (dialect.name === "postgres" && dbType.kind === "blob") {
+    return "bytea";
   }
-  return dbType.kind;
+  return renderDbTypeName(dbType.kind);
 };
+var isArrayDbType = (dbType) => ("element" in dbType);
 var renderCastType = (dialect, dbType) => {
+  const kind = dbType?.kind;
   if (dialect.name !== "mysql") {
-    return dbType.kind;
+    return renderDbTypeName(kind);
   }
-  switch (dbType.kind) {
+  switch (kind) {
     case "text":
       return "char";
     case "uuid":
@@ -3561,7 +3380,85 @@ var renderCastType = (dialect, dbType) => {
     case "json":
       return "json";
     default:
-      return dbType.kind;
+      return renderDbTypeName(kind);
+  }
+};
+var casingForTable = (table, state) => merge(state.casing, table[TypeId6].casing);
+var casedTableName = (table, state) => {
+  const tableState = table[TypeId6];
+  return applyCategory(casingForTable(table, state), "tables", tableState.baseName);
+};
+var casedSchemaName = (table, state) => {
+  const schemaName = table[TypeId6].schemaName;
+  return schemaName === undefined ? undefined : applyCategory(casingForTable(table, state), "schemas", schemaName);
+};
+var casedColumnName = (columnName, state, tableName) => {
+  if (tableName !== undefined) {
+    const mapped = state.sourceNames?.get(tableName)?.columns.get(columnName);
+    if (mapped !== undefined) {
+      return mapped;
+    }
+  }
+  return applyCategory(state.casing, "columns", columnName);
+};
+var casedTableReferenceName = (tableName, state) => state.sourceNames?.get(tableName)?.tableName ?? applyCategory(state.casing, "tables", tableName);
+var quoteColumn = (columnName, state, dialect, tableName) => dialect.quoteIdentifier(casedColumnName(columnName, state, tableName));
+var stateWithTableCasing = (state, source) => typeof source === "object" && source !== null && (TypeId6 in source) ? { ...state, casing: casingForTable(source, state) } : state;
+var referenceCasing = (reference, state) => merge(state.casing, reference.casing);
+var renderReferenceTable = (reference, state, dialect) => {
+  const casing = referenceCasing(reference, state);
+  const tableName = applyCategory(casing, "tables", reference.tableName);
+  const schemaName = reference.schemaName === undefined ? undefined : applyCategory(casing, "schemas", reference.schemaName);
+  return dialect.renderTableReference(tableName, tableName, schemaName);
+};
+var quoteReferenceColumn = (columnName, reference, state, dialect) => dialect.quoteIdentifier(applyCategory(referenceCasing(reference, state), "columns", columnName));
+var registerSourceReference = (source, tableName, state) => {
+  if (typeof source !== "object" || source === null) {
+    return;
+  }
+  if (TypeId6 in source) {
+    const table = source;
+    const tableState = table[TypeId6];
+    const casing = casingForTable(table, state);
+    const renderedTableName = tableState.kind === "alias" ? tableName : applyCategory(casing, "tables", tableState.baseName);
+    const columns = new Map(Object.keys(tableState.fields).map((columnName) => [
+      columnName,
+      applyCategory(casing, "columns", columnName)
+    ]));
+    state.sourceNames?.set(tableName, {
+      tableName: renderedTableName,
+      columns
+    });
+    return;
+  }
+  if ("columns" in source && typeof source.columns === "object" && source.columns !== null) {
+    state.sourceNames?.set(tableName, {
+      tableName,
+      columns: new Map(Object.keys(source.columns).map((columnName) => [columnName, columnName]))
+    });
+  }
+};
+var registerQuerySources = (ast, state) => {
+  if (ast.from !== undefined) {
+    registerSourceReference(ast.from.source, ast.from.tableName, state);
+  }
+  for (const source of ast.fromSources ?? []) {
+    registerSourceReference(source.source, source.tableName, state);
+  }
+  for (const join of ast.joins) {
+    registerSourceReference(join.source, join.tableName, state);
+  }
+  if (ast.into !== undefined) {
+    registerSourceReference(ast.into.source, ast.into.tableName, state);
+  }
+  if (ast.target !== undefined) {
+    registerSourceReference(ast.target.source, ast.target.tableName, state);
+  }
+  for (const target of ast.targets ?? []) {
+    registerSourceReference(target.source, target.tableName, state);
+  }
+  if (ast.using !== undefined) {
+    registerSourceReference(ast.using.source, ast.using.tableName, state);
   }
 };
 var renderPostgresDdlString = (value) => `'${value.replaceAll("'", "''")}'`;
@@ -3599,22 +3496,29 @@ var renderDdlExpression = (expression, state, dialect) => {
   if (isSchemaExpression(expression)) {
     return render(expression);
   }
-  return renderExpression(expression, state, {
+  return renderExpression2(expression, state, {
     ...dialect,
     renderLiteral: renderPostgresDdlLiteral
   });
 };
-var renderColumnDefinition = (dialect, state, columnName, column) => {
+var renderColumnDefinition = (dialect, state, columnName, column, tableName, casing) => {
+  const expressionState = { ...state, casing, rowLocalColumns: true };
+  if (dialect.name !== "postgres" && isArrayDbType(column.metadata.dbType)) {
+    throw new Error(`Unsupported ${dialect.name} array column options`);
+  }
   const clauses = [
-    dialect.quoteIdentifier(columnName),
-    column.metadata.ddlType ?? renderDbType(dialect, column.metadata.dbType)
+    quoteColumn(columnName, state, dialect, tableName),
+    column.metadata.ddlType === undefined ? renderDbType(dialect, column.metadata.dbType) : renderDbTypeName(column.metadata.ddlType)
   ];
   if (column.metadata.identity) {
+    if (dialect.name !== "postgres") {
+      throw new Error(`Unsupported ${dialect.name} identity column options`);
+    }
     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`);
+    clauses.push(`generated always as (${renderDdlExpression(column.metadata.generatedValue, expressionState, dialect)}) stored`);
   } else if (column.metadata.defaultValue) {
-    clauses.push(`default ${renderDdlExpression(column.metadata.defaultValue, state, dialect)}`);
+    clauses.push(`default ${renderDdlExpression(column.metadata.defaultValue, expressionState, dialect)}`);
   }
   if (!column.metadata.nullable) {
     clauses.push("not null");
@@ -3622,24 +3526,47 @@ var renderColumnDefinition = (dialect, state, columnName, column) => {
   return clauses.join(" ");
 };
 var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
+  const normalizedIfNotExists = normalizeStatementFlag(ifNotExists);
+  if (dialect.name !== "postgres" && normalizedIfNotExists) {
+    throw new Error(`Unsupported ${dialect.name} create table options`);
+  }
   const table = targetSource.source;
-  const fields = table[TypeId4].fields;
-  const definitions = Object.entries(fields).map(([columnName, column]) => renderColumnDefinition(dialect, state, columnName, column));
-  for (const option2 of table[OptionsSymbol]) {
+  const tableCasing = casingForTable(table, state);
+  const fields = table[TypeId6].fields;
+  const definitions = Object.entries(fields).map(([columnName, column]) => renderColumnDefinition(dialect, state, columnName, column, targetSource.tableName, tableCasing));
+  const options2 = table[OptionsSymbol];
+  const tableOptions = Array.isArray(options2) ? options2 : [options2];
+  validateOptions(table[TypeId6].name, fields, tableOptions);
+  for (const option2 of tableOptions) {
+    if (typeof option2 !== "object" || option2 === null || !("kind" in option2)) {
+      continue;
+    }
     switch (option2.kind) {
       case "primaryKey":
-        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" : ""}` : ""}`);
+        if (dialect.name !== "postgres" && (option2.deferrable || option2.initiallyDeferred)) {
+          throw new Error(`Unsupported ${dialect.name} primary key constraint options`);
+        }
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}primary key (${option2.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "unique":
-        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" : ""}` : ""}`);
+        if (dialect.name !== "postgres" && (option2.nullsNotDistinct || option2.deferrable || option2.initiallyDeferred)) {
+          throw new Error(`Unsupported ${dialect.name} unique constraint options`);
+        }
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}unique${option2.nullsNotDistinct ? " nulls not distinct" : ""} (${option2.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       case "foreignKey": {
-        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 !== undefined ? ` on delete ${renderReferentialAction(option2.onDelete)}` : ""}${option2.onUpdate !== undefined ? ` on update ${renderReferentialAction(option2.onUpdate)}` : ""}${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        if (dialect.name !== "postgres" && (option2.deferrable || option2.initiallyDeferred)) {
+          throw new Error(`Unsupported ${dialect.name} foreign key constraint options`);
+        }
+        const reference = typeof option2.references === "function" ? option2.references() : option2.references;
+        definitions.push(`${option2.name ? `constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} ` : ""}foreign key (${option2.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")}) references ${renderReferenceTable(reference, state, dialect)} (${reference.columns.map((column) => quoteReferenceColumn(column, reference, state, dialect)).join(", ")})${option2.onDelete !== undefined ? ` on delete ${renderReferentialAction(option2.onDelete)}` : ""}${option2.onUpdate !== undefined ? ` on update ${renderReferentialAction(option2.onUpdate)}` : ""}${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
         break;
       }
       case "check":
-        definitions.push(`constraint ${dialect.quoteIdentifier(option2.name)} check (${renderDdlExpression(option2.predicate, { ...state, rowLocalColumns: true }, dialect)})${option2.noInherit ? " no inherit" : ""}`);
+        if (dialect.name !== "postgres" && option2.noInherit) {
+          throw new Error(`Unsupported ${dialect.name} check constraint options`);
+        }
+        definitions.push(`constraint ${dialect.quoteIdentifier(applyCategory(tableCasing, "constraints", option2.name))} check (${renderDdlExpression(option2.predicate, { ...state, casing: tableCasing, rowLocalColumns: true }, dialect)})${option2.noInherit ? " no inherit" : ""}`);
         break;
       case "index":
         break;
@@ -3647,21 +3574,40 @@ var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
         throw new Error("Unsupported table option kind");
     }
   }
-  return `create table${ifNotExists ? " if not exists" : ""} ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${definitions.join(", ")})`;
+  return `create table${normalizedIfNotExists ? " if not exists" : ""} ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${definitions.join(", ")})`;
 };
 var renderCreateIndexSql = (targetSource, ddl, state, dialect) => {
-  const maybeIfNotExists = dialect.name === "postgres" && ddl.ifNotExists ? " if not exists" : "";
-  return `create${ddl.unique ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`;
+  const unique2 = normalizeStatementFlag(ddl.unique);
+  const ifNotExists = normalizeStatementFlag(ddl.ifNotExists);
+  const name = normalizeStatementIdentifier("createIndex", "option 'name'", ddl.name);
+  if (dialect.name !== "postgres" && ifNotExists) {
+    throw new Error(`Unsupported ${dialect.name} create index options`);
+  }
+  const maybeIfNotExists = dialect.name === "postgres" && ifNotExists ? " if not exists" : "";
+  const table = targetSource.source;
+  const tableCasing = casingForTable(table, state);
+  return `create${unique2 ? " unique" : ""} index${maybeIfNotExists} ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} (${ddl.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})`;
 };
 var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
+  const ifExists = normalizeStatementFlag(ddl.ifExists);
+  const name = normalizeStatementIdentifier("dropIndex", "option 'name'", ddl.name);
+  if (dialect.name !== "postgres" && ifExists) {
+    throw new Error(`Unsupported ${dialect.name} drop index options`);
+  }
   if (dialect.name === "postgres") {
-    const schemaName = typeof targetSource.source === "object" && targetSource.source !== null && TypeId4 in targetSource.source ? targetSource.source[TypeId4].schemaName : undefined;
-    const indexName = schemaName === undefined || schemaName === "public" ? dialect.quoteIdentifier(ddl.name) : `${dialect.quoteIdentifier(schemaName)}.${dialect.quoteIdentifier(ddl.name)}`;
-    return `drop index${ddl.ifExists ? " if exists" : ""} ${indexName}`;
+    const table2 = typeof targetSource.source === "object" && targetSource.source !== null && TypeId6 in targetSource.source ? targetSource.source : undefined;
+    const schemaName = table2?.[TypeId6].schemaName;
+    const tableCasing2 = table2 === undefined ? state.casing : casingForTable(table2, state);
+    const renderedSchemaName = table2 === undefined ? schemaName : casedSchemaName(table2, state);
+    const renderedIndexName = applyCategory(tableCasing2, "indexes", name);
+    const indexName = schemaName === undefined || schemaName === "public" ? dialect.quoteIdentifier(renderedIndexName) : `${dialect.quoteIdentifier(renderedSchemaName ?? schemaName)}.${dialect.quoteIdentifier(renderedIndexName)}`;
+    return `drop index${ifExists ? " if exists" : ""} ${indexName}`;
   }
-  return `drop index ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
+  const table = targetSource.source;
+  const tableCasing = casingForTable(table, state);
+  return `drop index ${dialect.quoteIdentifier(applyCategory(tableCasing, "indexes", name))} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
 };
-var isExpression4 = (value) => value !== null && typeof value === "object" && (TypeId2 in value);
+var isExpression3 = (value) => value !== null && typeof value === "object" && (TypeId2 in value);
 var isJsonDbType2 = (dbType) => {
   if (dbType.kind === "jsonb" || dbType.kind === "json") {
     return true;
@@ -3672,7 +3618,13 @@ var isJsonDbType2 = (dbType) => {
   const variant = dbType.variant;
   return variant === "json" || variant === "jsonb";
 };
-var isJsonExpression = (value) => isExpression4(value) && isJsonDbType2(value[TypeId2].dbType);
+var isJsonExpression = (value) => isExpression3(value) && isJsonDbType2(value[TypeId2].dbType);
+var expectValueExpression = (_functionName, value) => value;
+var expectBinaryExpressions = (_functionName, left, right) => [left, right];
+var renderBinaryExpression = (functionName, operator, left, right, state, dialect) => {
+  const [leftExpression, rightExpression] = expectBinaryExpressions(functionName, left, right);
+  return `(${renderExpression2(leftExpression, state, dialect)} ${operator} ${renderExpression2(rightExpression, state, dialect)})`;
+};
 var postgresRangeSubtypeByKind = {
   int4range: "int4",
   int8range: "int8",
@@ -3713,14 +3665,53 @@ var unsupportedJsonFeature = (dialect, feature) => {
   throw error;
 };
 var extractJsonBase = (node) => node.value ?? node.base ?? node.input ?? node.left ?? node.target;
-var isJsonPathValue = (value) => value !== null && typeof value === "object" && (TypeId7 in value);
+var isJsonPathValue = (value) => value !== null && typeof value === "object" && (TypeId8 in value);
+var isOptionalJsonPathNumber = (value) => value === undefined || typeof value === "number" && Number.isFinite(value);
+var isJsonPathSegment = (segment) => {
+  if (typeof segment === "string") {
+    return true;
+  }
+  if (typeof segment === "number") {
+    return Number.isFinite(segment);
+  }
+  if (segment === null || typeof segment !== "object" || !("kind" in segment)) {
+    return false;
+  }
+  switch (segment.kind) {
+    case "key":
+      return typeof segment.key === "string";
+    case "index": {
+      const index3 = segment.index;
+      return typeof index3 === "number" && Number.isFinite(index3);
+    }
+    case "wildcard":
+    case "descend":
+      return true;
+    case "slice":
+      return isOptionalJsonPathNumber(segment.start) && isOptionalJsonPathNumber(segment.end);
+    default:
+      return false;
+  }
+};
+var validateJsonPathSegments = (segments) => {
+  if (!Array.isArray(segments)) {
+    throw new Error("JSON path expressions require a segment array");
+  }
+  if (segments.some((segment) => !isJsonPathSegment(segment))) {
+    throw new Error("JSON path segments require string, number, or path segment objects");
+  }
+  return segments;
+};
 var extractJsonPathSegments = (node) => {
   const path2 = node.path ?? node.segments ?? node.keys;
   if (isJsonPathValue(path2)) {
-    return path2.segments;
+    return validateJsonPathSegments(path2.segments);
   }
   if (Array.isArray(path2)) {
-    return path2;
+    return validateJsonPathSegments(path2);
+  }
+  if (node.segments !== undefined) {
+    return validateJsonPathSegments(node.segments);
   }
   if ("key" in node) {
     return [key(String(node.key))];
@@ -3739,10 +3730,11 @@ var extractJsonPathSegments = (node) => {
     return [];
   }
   if ("right" in node && isJsonPathValue(node.right)) {
-    return node.right.segments;
+    return validateJsonPathSegments(node.right.segments);
   }
   return [];
 };
+var extractJsonKeys = (node, segments) => Array.isArray(node.keys) ? node.keys : segments.map((segment) => typeof segment === "object" && segment !== null && segment.kind === "key" ? segment.key : segment);
 var extractJsonValue = (node) => node.newValue ?? node.insert ?? node.right;
 var renderJsonPathSegment = (segment) => {
   const renderKey = (value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) ? `.${value}` : `.${JSON.stringify(value)}`;
@@ -3803,10 +3795,10 @@ var renderPostgresJsonAccessStep = (segment, textMode, state, dialect) => {
   }
 };
 var renderPostgresJsonValue = (value, state, dialect) => {
-  if (!isExpression4(value)) {
+  if (!isExpression3(value)) {
     throw new Error("Expected a JSON expression");
   }
-  const rendered = renderExpression(value, state, dialect);
+  const rendered = renderExpression2(value, state, dialect);
   const ast = value[TypeId3];
   if (ast.kind === "literal") {
     return `cast(${rendered} as jsonb)`;
@@ -3820,7 +3812,7 @@ var expressionDriverContext = (expression, state, dialect) => ({
   runtimeSchema: expression[TypeId2].runtimeSchema,
   driverValueMapping: expression[TypeId2].driverValueMapping
 });
-var renderJsonInputExpression = (expression, state, dialect) => renderJsonSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect));
+var renderJsonInputExpression = (expression, state, dialect) => renderJsonSelectSql(renderExpression2(expression, state, dialect), expressionDriverContext(expression, state, dialect));
 var encodeArrayValues = (values, column, state, dialect) => values.map((value) => {
   if (value === null && column.metadata.nullable) {
     return null;
@@ -3842,44 +3834,52 @@ var renderJsonOpaquePath = (value, state, dialect) => {
     return dialect.renderLiteral(renderJsonPathStringLiteral(value.segments), state);
   }
   if (typeof value === "string") {
+    if (value.trim().length === 0) {
+      throw new Error("SQL/JSON path input must be a non-empty string");
+    }
     return dialect.renderLiteral(value, state);
   }
-  if (isExpression4(value)) {
-    return renderExpression(value, state, dialect);
+  if (isExpression3(value)) {
+    const ast = value[TypeId3];
+    if (ast.kind === "literal" && typeof ast.value === "string" && ast.value.trim().length === 0) {
+      throw new Error("SQL/JSON path input must be a non-empty string");
+    }
+    return renderExpression2(value, state, dialect);
   }
   throw new Error("Unsupported SQL/JSON path input");
 };
+var renderFunctionName = (name) => {
+  return name;
+};
+var renderExtractField = (field) => {
+  const ast = field[TypeId3];
+  return ast.value;
+};
 var renderFunctionCall = (name, args, state, dialect) => {
-  if (name === "array") {
-    return `ARRAY[${args.map((arg) => renderExpression(arg, state, dialect)).join(", ")}]`;
-  }
-  if (name === "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 = isExpression4(field) && field[TypeId2].dbType.kind === "text" && typeof field[TypeId2].runtime === "string" ? field[TypeId2].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) {
+  const functionName = renderFunctionName(name);
+  const functionArgs = args;
+  if (functionName === "array") {
+    return `ARRAY[${functionArgs.map((arg) => renderExpression2(arg, state, dialect)).join(", ")}]`;
+  }
+  if (functionName === "extract") {
+    const field = functionArgs[0];
+    const source = functionArgs[1];
+    return `extract(${renderExtractField(field)} from ${renderExpression2(source, state, dialect)})`;
+  }
+  const renderedArgs = functionArgs.map((arg) => renderExpression2(arg, state, dialect)).join(", ");
+  if (functionArgs.length === 0) {
+    switch (functionName) {
       case "current_date":
       case "current_time":
       case "current_timestamp":
       case "localtime":
       case "localtimestamp":
-        return name;
+        return functionName;
       default:
-        return `${name}()`;
+        return `${functionName}()`;
     }
   }
-  return `${name}(${renderedArgs})`;
+  return `${functionName}(${renderedArgs})`;
 };
 var renderJsonExpression = (expression, ast, state, dialect) => {
   const kind = typeof ast.kind === "string" ? ast.kind : undefined;
@@ -3900,10 +3900,10 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonPathText":
     case "jsonAccessText":
     case "jsonTraverseText": {
-      if (!isExpression4(base) || segments.length === 0) {
+      if (!isExpression3(base) || segments.length === 0) {
         return;
       }
-      const baseSql = renderExpression(base, state, dialect);
+      const baseSql = renderExpression2(base, state, dialect);
       const textMode = kind.endsWith("Text") || ast.text === true || ast.asText === true;
       if (dialect.name === "postgres") {
         if (exact) {
@@ -3923,45 +3923,49 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys": {
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
-      const baseSql = dialect.name === "postgres" ? renderPostgresJsonValue(base, state, dialect) : renderExpression(base, state, dialect);
-      const keys = segments;
+      const baseSql = dialect.name === "postgres" ? renderPostgresJsonValue(base, state, dialect) : renderExpression2(base, state, dialect);
+      const keys = extractJsonKeys(ast, segments);
       if (keys.length === 0) {
         return;
       }
+      if (keys.some((key2) => typeof key2 !== "string" || key2.length === 0)) {
+        throw new Error("json key predicates require string keys");
+      }
+      const keyNames = keys;
       if (dialect.name === "postgres") {
         if (kind === "jsonHasAnyKeys") {
-          return `(${baseSql} ?| array[${keys.map((key2) => renderPostgresTextLiteral(String(key2), state, dialect)).join(", ")}])`;
+          return `(${baseSql} ?| array[${keyNames.map((key2) => renderPostgresTextLiteral(key2, state, dialect)).join(", ")}])`;
         }
         if (kind === "jsonHasAllKeys") {
-          return `(${baseSql} ?& array[${keys.map((key2) => renderPostgresTextLiteral(String(key2), state, dialect)).join(", ")}])`;
+          return `(${baseSql} ?& array[${keyNames.map((key2) => renderPostgresTextLiteral(key2, state, dialect)).join(", ")}])`;
         }
-        return `(${baseSql} ? ${renderPostgresTextLiteral(String(keys[0]), state, dialect)})`;
+        return `(${baseSql} ? ${renderPostgresTextLiteral(keyNames[0], state, dialect)})`;
       }
       if (dialect.name === "mysql") {
         const mode = kind === "jsonHasAllKeys" ? "all" : "one";
-        const paths = keys.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ");
+        const paths = keyNames.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ");
         return `json_contains_path(${baseSql}, ${dialect.renderLiteral(mode, state)}, ${paths})`;
       }
       return;
     }
     case "jsonConcat":
     case "jsonMerge": {
-      if (!isExpression4(ast.left) || !isExpression4(ast.right)) {
+      if (!isExpression3(ast.left) || !isExpression3(ast.right)) {
         return;
       }
       if (dialect.name === "postgres") {
         return `(${renderPostgresJsonValue(ast.left, state, dialect)} || ${renderPostgresJsonValue(ast.right, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `json_merge_preserve(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`;
+        return `json_merge_preserve(${renderExpression2(ast.left, state, dialect)}, ${renderExpression2(ast.right, state, dialect)})`;
       }
       return;
     }
     case "jsonBuildObject": {
-      const entries = Array.isArray(ast.entries) ? ast.entries : [];
+      const entries = ast.entries;
       const renderedEntries = entries.flatMap((entry) => [
         dialect.renderLiteral(entry.key, state),
         renderJsonInputExpression(entry.value, state, dialect)
@@ -3975,7 +3979,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonBuildArray": {
-      const values = Array.isArray(ast.values) ? ast.values : [];
+      const values = ast.values;
       const renderedValues = values.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ");
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`;
@@ -3986,81 +3990,81 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonToJson":
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
       if (dialect.name === "postgres") {
         return `to_json(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `cast(${renderExpression(base, state, dialect)} as json)`;
+        return `cast(${renderExpression2(base, state, dialect)} as json)`;
       }
       return;
     case "jsonToJsonb":
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
       if (dialect.name === "postgres") {
         return `to_jsonb(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `cast(${renderExpression(base, state, dialect)} as json)`;
+        return `cast(${renderExpression2(base, state, dialect)} as json)`;
       }
       return;
     case "jsonTypeOf":
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
       if (dialect.name === "postgres") {
-        const baseSql = renderExpression(base, state, dialect);
+        const baseSql = renderExpression2(base, state, dialect);
         return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof(${baseSql})`;
       }
       if (dialect.name === "mysql") {
-        return `json_type(${renderExpression(base, state, dialect)})`;
+        return `json_type(${renderExpression2(base, state, dialect)})`;
       }
       return;
     case "jsonLength":
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
       if (dialect.name === "postgres") {
-        const baseSql = renderExpression(base, state, dialect);
+        const baseSql = renderExpression2(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)})`;
+        return `json_length(${renderExpression2(base, state, dialect)})`;
       }
       return;
     case "jsonKeys":
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
       if (dialect.name === "postgres") {
-        const baseSql = renderExpression(base, state, dialect);
+        const baseSql = renderExpression2(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 to_json(array(select ${objectKeys}(${baseSql}))) else null end)`;
       }
       if (dialect.name === "mysql") {
-        return `json_keys(${renderExpression(base, state, dialect)})`;
+        return `json_keys(${renderExpression2(base, state, dialect)})`;
       }
       return;
     case "jsonStripNulls":
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
       if (dialect.name === "postgres") {
-        return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_strip_nulls(${renderExpression(base, state, dialect)})`;
+        return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_strip_nulls(${renderExpression2(base, state, dialect)})`;
       }
       unsupportedJsonFeature(dialect, "jsonStripNulls");
       return;
     case "jsonDelete":
     case "jsonDeletePath":
     case "jsonRemove": {
-      if (!isExpression4(base) || segments.length === 0) {
+      if (!isExpression3(base) || segments.length === 0) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -4072,17 +4076,17 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return `(${baseSql} #- ${renderPostgresJsonPathArray(segments, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `json_remove(${renderExpression(base, state, dialect)}, ${segments.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ")})`;
+        return `json_remove(${renderExpression2(base, state, dialect)}, ${segments.map((segment) => renderMySqlJsonPath([segment], state, dialect)).join(", ")})`;
       }
       return;
     }
     case "jsonSet":
     case "jsonInsert": {
-      if (!isExpression4(base) || segments.length === 0) {
+      if (!isExpression3(base) || segments.length === 0) {
         return;
       }
       const nextValue = extractJsonValue(ast);
-      if (!isExpression4(nextValue)) {
+      if (!isExpression3(nextValue)) {
         return;
       }
       const createMissing = ast.createMissing === true;
@@ -4094,12 +4098,12 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       if (dialect.name === "mysql") {
         const functionName = kind === "jsonInsert" ? "json_insert" : "json_set";
-        return `${functionName}(${renderExpression(base, state, dialect)}, ${renderMySqlJsonPath(segments, state, dialect)}, ${renderExpression(nextValue, state, dialect)})`;
+        return `${functionName}(${renderExpression2(base, state, dialect)}, ${renderMySqlJsonPath(segments, state, dialect)}, ${renderExpression2(nextValue, state, dialect)})`;
       }
       return;
     }
     case "jsonPathExists": {
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -4110,12 +4114,12 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return `(${renderPostgresJsonValue(base, state, dialect)} @? ${renderJsonOpaquePath(path2, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
-        return `json_contains_path(${renderExpression(base, state, dialect)}, ${dialect.renderLiteral("one", state)}, ${renderJsonOpaquePath(path2, state, dialect)})`;
+        return `json_contains_path(${renderExpression2(base, state, dialect)}, ${dialect.renderLiteral("one", state)}, ${renderJsonOpaquePath(path2, state, dialect)})`;
       }
       return;
     }
     case "jsonPathMatch": {
-      if (!isExpression4(base)) {
+      if (!isExpression3(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -4134,19 +4138,14 @@ var selectionProjections = (selection) => flattenSelection(selection).map(({ pat
   path: path2,
   alias: alias2
 }));
-var renderMutationAssignment = (entry, state, dialect) => {
-  const column = entry.tableName && dialect.name === "mysql" ? `${dialect.quoteIdentifier(entry.tableName)}.${dialect.quoteIdentifier(entry.columnName)}` : dialect.quoteIdentifier(entry.columnName);
-  return `${column} = ${renderExpression(entry.value, state, dialect)}`;
+var renderMutationAssignment = (entry, state, dialect, targetTableName) => {
+  const column = entry.tableName && dialect.name === "mysql" ? `${dialect.quoteIdentifier(casedTableReferenceName(entry.tableName, state))}.${quoteColumn(entry.columnName, state, dialect, entry.tableName)}` : quoteColumn(entry.columnName, state, dialect, targetTableName);
+  return `${column} = ${renderExpression2(entry.value, state, dialect)}`;
 };
 var renderJoinSourcesForMutation = (joins, state, dialect) => joins.map((join) => renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)).join(", ");
 var renderFromSources = (sources, state, dialect) => sources.map((source) => renderSourceReference(source.source, source.tableName, source.baseTableName, state, dialect)).join(", ");
-var renderJoinPredicatesForMutation = (joins, state, dialect) => joins.flatMap((join) => join.kind === "cross" || !join.on ? [] : [renderExpression(join.on, state, dialect)]);
+var renderJoinPredicatesForMutation = (joins, state, dialect) => joins.flatMap((join) => join.kind === "cross" || !join.on ? [] : [renderExpression2(join.on, state, dialect)]);
 var renderDeleteTargets = (targets, dialect) => targets.map((target) => dialect.quoteIdentifier(target.tableName)).join(", ");
-var assertMergeActionKind = (kind, allowed) => {
-  if (typeof kind !== "string" || !allowed.includes(kind)) {
-    throw new Error("Unsupported merge action kind");
-  }
-};
 var renderMysqlMutationLock = (lock, statement) => {
   if (!lock) {
     return "";
@@ -4170,7 +4169,7 @@ var renderTransactionClause = (clause, dialect) => {
       if (isolationLevel) {
         modes.push(isolationLevel);
       }
-      if (clause.readOnly === true) {
+      if (normalizeStatementFlag(clause.readOnly)) {
         modes.push("read only");
       }
       return modes.length > 0 ? `start transaction ${modes.join(", ")}` : "start transaction";
@@ -4180,24 +4179,18 @@ var renderTransactionClause = (clause, dialect) => {
     case "rollback":
       return "rollback";
     case "savepoint":
-      return `savepoint ${dialect.quoteIdentifier(clause.name)}`;
+      return `savepoint ${dialect.quoteIdentifier(normalizeStatementIdentifier("savepoint", "name", clause.name))}`;
     case "rollbackTo":
-      return `rollback to savepoint ${dialect.quoteIdentifier(clause.name)}`;
+      return `rollback to savepoint ${dialect.quoteIdentifier(normalizeStatementIdentifier("rollbackTo", "name", clause.name))}`;
     case "releaseSavepoint":
-      return `release savepoint ${dialect.quoteIdentifier(clause.name)}`;
+      return `release savepoint ${dialect.quoteIdentifier(normalizeStatementIdentifier("releaseSavepoint", "name", clause.name))}`;
   }
-  throw new Error("Unsupported transaction statement kind");
+  return "start transaction";
 };
-var renderSelectionList = (selection, state, dialect, validateAggregation) => {
-  if (validateAggregation) {
-    validateAggregationSelection(selection, []);
-  }
+var renderSelectionList = (selection, state, dialect) => {
   const flattened = flattenSelection(selection);
-  if (dialect.name === "mysql" && flattened.length === 0) {
-    throw new Error("mysql select statements require at least one selected expression");
-  }
   const projections = selectionProjections(selection);
-  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
+  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderSelectSql(renderExpression2(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
   return {
     sql,
     projections
@@ -4206,120 +4199,78 @@ var renderSelectionList = (selection, state, dialect, validateAggregation) => {
 var nestedRenderState = (state) => ({
   params: state.params,
   valueMappings: state.valueMappings,
+  casing: state.casing,
   ctes: [],
   cteNames: new Set(state.cteNames),
-  cteSources: new Map(state.cteSources)
+  cteSources: new Map(state.cteSources),
+  sourceNames: new Map(state.sourceNames)
 });
-var assertMatchingSetProjections = (left, right) => {
-  const leftKeys = left.map((projection) => JSON.stringify(projection.path));
-  const rightKeys = right.map((projection) => JSON.stringify(projection.path));
-  if (leftKeys.length !== rightKeys.length || leftKeys.some((key2, index3) => key2 !== rightKeys[index3])) {
-    throw new Error("set operator operands must have matching result rows");
+var assertSupportedMutationReturning = (dialect, selection) => {
+  if (dialect.name === "standard" && Object.keys(selection).length > 0) {
+    throw new Error("Unsupported standard returning");
   }
 };
-var assertNoGroupedMutationClauses = (ast, statement) => {
-  if (ast.groupBy.length > 0) {
-    throw new Error(`groupBy(...) is not supported for ${statement} statements`);
-  }
-  if (ast.having.length > 0) {
-    throw new Error(`having(...) is not supported for ${statement} statements`);
-  }
-};
-var assertNoInsertQueryClauses = (ast) => {
-  if (ast.where.length > 0) {
-    throw new Error("where(...) is not supported for insert statements");
-  }
-  if (ast.joins.length > 0) {
-    throw new Error("join(...) is not supported for insert statements");
-  }
-  if (ast.orderBy.length > 0) {
-    throw new Error("orderBy(...) is not supported for insert statements");
-  }
-  if (ast.limit) {
-    throw new Error("limit(...) is not supported for insert statements");
-  }
-  if (ast.offset) {
-    throw new Error("offset(...) is not supported for insert statements");
-  }
-  if (ast.lock) {
-    throw new Error("lock(...) is not supported for insert statements");
-  }
-};
-var assertNoStatementQueryClauses = (ast, statement, options2 = {}) => {
-  if (ast.distinct) {
-    throw new Error(`distinct(...) is not supported for ${statement} statements`);
-  }
-  if (ast.where.length > 0) {
-    throw new Error(`where(...) is not supported for ${statement} statements`);
-  }
-  if ((ast.fromSources?.length ?? 0) > 0 || ast.from) {
-    throw new Error(`from(...) is not supported for ${statement} statements`);
-  }
-  if (ast.joins.length > 0) {
-    throw new Error(`join(...) is not supported for ${statement} statements`);
-  }
-  if (ast.groupBy.length > 0) {
-    throw new Error(`groupBy(...) is not supported for ${statement} statements`);
-  }
-  if (ast.having.length > 0) {
-    throw new Error(`having(...) is not supported for ${statement} statements`);
-  }
-  if (ast.orderBy.length > 0) {
-    throw new Error(`orderBy(...) is not supported for ${statement} statements`);
-  }
-  if (ast.limit) {
-    throw new Error(`limit(...) is not supported for ${statement} statements`);
-  }
-  if (ast.offset) {
-    throw new Error(`offset(...) is not supported for ${statement} statements`);
-  }
-  if (ast.lock) {
-    throw new Error(`lock(...) is not supported for ${statement} statements`);
+var validateDistinctOnOrdering = (distinctOn, orderBy) => {
+  if (distinctOn === undefined || distinctOn.length === 0 || orderBy.length === 0) {
+    return;
   }
-  if (options2.allowSelection !== true && Object.keys(ast.select).length > 0) {
-    throw new Error(`returning(...) is not supported for ${statement} statements`);
+  const remainingDistinctKeys = new Set(distinctOn.map(groupingKeyOfExpression));
+  for (const order of orderBy) {
+    const key2 = groupingKeyOfExpression(order.value);
+    if (remainingDistinctKeys.has(key2)) {
+      remainingDistinctKeys.delete(key2);
+      continue;
+    }
+    if (remainingDistinctKeys.size > 0) {
+      throw new Error("distinctOn(...) expressions must match the leftmost orderBy(...) expressions");
+    }
+    return;
   }
 };
-var renderQueryAst = (ast, state, dialect, options2 = {}) => {
+var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
+  registerQuerySources(ast, state);
   let sql = "";
   let projections = [];
   switch (ast.kind) {
     case "select": {
-      validateAggregationSelection(ast.select, ast.groupBy);
-      const rendered = renderSelectionList(ast.select, state, dialect, false);
+      validateDistinctOnOrdering(ast.distinctOn, ast.orderBy);
+      const rendered = renderSelectionList(ast.select, state, dialect);
       projections = rendered.projections;
       const selectList = rendered.sql.length > 0 ? ` ${rendered.sql}` : "";
       const clauses = [
-        ast.distinctOn && ast.distinctOn.length > 0 ? `select distinct on (${ast.distinctOn.map((value) => renderExpression(value, state, dialect)).join(", ")})${selectList}` : `select${ast.distinct ? " distinct" : ""}${selectList}`
+        ast.distinctOn && ast.distinctOn.length > 0 ? `select distinct on (${ast.distinctOn.map((value) => renderExpression2(value, state, dialect)).join(", ")})${selectList}` : `select${ast.distinct ? " distinct" : ""}${selectList}`
       ];
       if (ast.from) {
         clauses.push(`from ${renderSourceReference(ast.from.source, ast.from.tableName, ast.from.baseTableName, state, dialect)}`);
       }
       for (const join of ast.joins) {
+        if (dialect.name === "standard" && join.kind === "full") {
+          throw new Error("Unsupported standard full join");
+        }
         const source = renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect);
-        clauses.push(join.kind === "cross" ? `cross join ${source}` : `${join.kind} join ${source} on ${renderExpression(join.on, state, dialect)}`);
+        clauses.push(join.kind === "cross" ? `cross join ${source}` : `${join.kind} join ${source} on ${renderExpression2(join.on, state, dialect)}`);
       }
       if (ast.where.length > 0) {
-        clauses.push(`where ${ast.where.map((entry) => renderExpression(entry.predicate, state, dialect)).join(" and ")}`);
+        clauses.push(`where ${ast.where.map((entry) => renderExpression2(entry.predicate, state, dialect)).join(" and ")}`);
       }
       if (ast.groupBy.length > 0) {
-        clauses.push(`group by ${ast.groupBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`);
+        clauses.push(`group by ${ast.groupBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
       }
       if (ast.having.length > 0) {
-        clauses.push(`having ${ast.having.map((entry) => renderExpression(entry.predicate, state, dialect)).join(" and ")}`);
+        clauses.push(`having ${ast.having.map((entry) => renderExpression2(entry.predicate, state, dialect)).join(" and ")}`);
       }
       if (ast.orderBy.length > 0) {
-        clauses.push(`order by ${ast.orderBy.map((entry) => `${renderExpression(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
+        clauses.push(`order by ${ast.orderBy.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
       }
       if (ast.limit) {
-        clauses.push(`limit ${renderExpression(ast.limit, state, dialect)}`);
+        clauses.push(`limit ${renderExpression2(ast.limit, state, dialect)}`);
       }
       if (ast.offset) {
-        clauses.push(`offset ${renderExpression(ast.offset, state, dialect)}`);
+        clauses.push(`offset ${renderExpression2(ast.offset, state, dialect)}`);
       }
       if (ast.lock) {
-        if (ast.lock.nowait && ast.lock.skipLocked) {
-          throw new Error("lock(...) cannot specify both nowait and skipLocked");
+        if (dialect.name === "standard") {
+          throw new Error("Unsupported standard row locking");
         }
         clauses.push(`${renderSelectLockMode(ast.lock.mode)}${ast.lock.nowait ? " nowait" : ""}${ast.lock.skipLocked ? " skip locked" : ""}`);
       }
@@ -4328,15 +4279,15 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
     }
     case "set": {
       const setAst = ast;
-      assertNoStatementQueryClauses(setAst, "set", { allowSelection: true });
-      const base = renderQueryAst(getAst(setAst.setBase), state, dialect);
+      const base = renderQueryAst2(getAst(setAst.setBase), state, dialect);
       projections = selectionProjections(setAst.select);
-      assertMatchingSetProjections(projections, base.projections);
       sql = [
         `(${base.sql})`,
         ...(setAst.setOperations ?? []).map((entry) => {
-          const rendered = renderQueryAst(getAst(entry.query), state, dialect);
-          assertMatchingSetProjections(projections, rendered.projections);
+          const rendered = renderQueryAst2(getAst(entry.query), state, dialect);
+          if (dialect.name === "standard" && entry.all && entry.kind !== "union") {
+            throw new Error("Unsupported standard set operator all variant");
+          }
           return `${entry.kind}${entry.all ? " all" : ""} (${rendered.sql})`;
         })
       ].join(" ");
@@ -4344,61 +4295,60 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
     }
     case "insert": {
       const insertAst = ast;
-      if (insertAst.distinct) {
-        throw new Error("distinct(...) is not supported for insert statements");
-      }
-      assertNoGroupedMutationClauses(insertAst, "insert");
-      assertNoInsertQueryClauses(insertAst);
       const targetSource = insertAst.into;
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect);
-      const insertSource = expectInsertSourceKind(insertAst.insertSource);
+      const targetCasingState = stateWithTableCasing(state, targetSource.source);
+      const insertSource = insertAst.insertSource;
       const conflict = expectConflictClause(insertAst.conflict);
       sql = `insert into ${target}`;
       if (insertSource?.kind === "values") {
-        const columns = insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
-        const rows = insertSource.rows.map((row) => `(${row.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`).join(", ");
+        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ");
+        const rows = insertSource.rows.map((row) => `(${row.values.map((entry) => renderExpression2(entry.value, targetCasingState, dialect)).join(", ")})`).join(", ");
         sql += ` (${columns}) values ${rows}`;
       } else if (insertSource?.kind === "query") {
-        const columns = insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
-        const renderedQuery = renderQueryAst(getAst(insertSource.query), state, dialect);
+        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ");
+        const renderedQuery = renderQueryAst2(getAst(insertSource.query), state, dialect);
         sql += ` (${columns}) ${renderedQuery.sql}`;
       } else if (insertSource?.kind === "unnest") {
-        const columns = insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
+        const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
-          const fields = table[TypeId4].fields;
+          const fields = table[TypeId6].fields;
           const rendered = insertSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields[entry.columnName].metadata.dbType)}[])`).join(", ");
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
           const rowCount = insertSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index3) => `(${insertSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId4].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
+          const rows = Array.from({ length: rowCount }, (_, index3) => `(${insertSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId6].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
-        const columns = (insertAst.values ?? []).map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ");
-        const values = (insertAst.values ?? []).map((entry) => renderExpression(entry.value, state, dialect)).join(", ");
-        if ((insertAst.values ?? []).length > 0) {
+        const insertValues = insertAst.values ?? [];
+        const columns = insertValues.map((entry) => quoteColumn(entry.columnName, state, dialect, targetSource.tableName)).join(", ");
+        const values = insertValues.map((entry) => renderExpression2(entry.value, targetCasingState, dialect)).join(", ");
+        if (insertValues.length > 0) {
           sql += ` (${columns}) values (${values})`;
         } else {
           sql += " default values";
         }
       }
       if (conflict) {
-        if (conflict.action === "doNothing" && conflict.where) {
-          throw new Error("conflict action predicates require update assignments");
+        if (dialect.name === "standard") {
+          throw new Error("Unsupported standard insert conflict");
         }
-        const updateValues = (conflict.values ?? []).map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ");
+        const conflictValueState = { ...targetCasingState, allowExcluded: true };
+        const updateValues = (conflict.values ?? []).map((entry) => `${quoteColumn(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression2(entry.value, conflictValueState, dialect)}`).join(", ");
         if (dialect.name === "postgres") {
-          const targetSql = conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(conflict.target.name)}` : conflict.target?.kind === "columns" ? ` on conflict (${conflict.target.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${conflict.target.where ? ` where ${renderExpression(conflict.target.where, state, dialect)}` : ""}` : " on conflict";
+          const targetSql = conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(applyCategory(targetCasingState.casing, "constraints", conflict.target.name))}` : conflict.target?.kind === "columns" ? ` on conflict (${conflict.target.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ")})${conflict.target.where ? ` where ${renderExpression2(conflict.target.where, targetCasingState, dialect)}` : ""}` : " on conflict";
           sql += targetSql;
-          sql += conflict.action === "doNothing" ? " do nothing" : ` do update set ${updateValues}${conflict.where ? ` where ${renderExpression(conflict.where, state, dialect)}` : ""}`;
+          sql += conflict.action === "doNothing" ? " do nothing" : ` do update set ${updateValues}${conflict.where ? ` where ${renderExpression2(conflict.where, conflictValueState, dialect)}` : ""}`;
         } else if (conflict.action === "doNothing") {
           sql = sql.replace(/^insert/, "insert ignore");
         } else {
           sql += ` on duplicate key update ${updateValues}`;
         }
       }
-      const returning = renderSelectionList(insertAst.select, state, dialect, false);
+      assertSupportedMutationReturning(dialect, insertAst.select);
+      const returning = renderSelectionList(insertAst.select, state, dialect);
       projections = returning.projections;
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`;
@@ -4407,34 +4357,18 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
     }
     case "update": {
       const updateAst = ast;
-      if (updateAst.distinct) {
-        throw new Error("distinct(...) is not supported for update statements");
-      }
-      assertNoGroupedMutationClauses(updateAst, "update");
-      if (updateAst.orderBy.length > 0) {
-        throw new Error("orderBy(...) is not supported for update statements");
-      }
-      if (updateAst.limit) {
-        throw new Error("limit(...) is not supported for update statements");
-      }
-      if (updateAst.offset) {
-        throw new Error("offset(...) is not supported for update statements");
-      }
-      if (updateAst.lock) {
-        throw new Error("lock(...) is not supported for update statements");
-      }
       const targetSource = updateAst.target;
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect);
       const targets = updateAst.targets ?? [targetSource];
       const fromSources = updateAst.fromSources ?? [];
-      if ((updateAst.set ?? []).length === 0) {
-        throw new Error("update statements require at least one assignment");
+      if (dialect.name === "standard" && (targets.length > 1 || fromSources.length > 0 || updateAst.joins.length > 0)) {
+        throw new Error("Unsupported standard joined mutation");
       }
-      const assignments = updateAst.set.map((entry) => renderMutationAssignment(entry, state, dialect)).join(", ");
+      const assignments = updateAst.set.map((entry) => renderMutationAssignment(entry, state, dialect, targetSource.tableName)).join(", ");
       if (dialect.name === "mysql") {
         const modifiers = renderMysqlMutationLock(updateAst.lock, "update");
         const extraSources = renderFromSources(fromSources, state, dialect);
-        const joinSources = updateAst.joins.map((join) => join.kind === "cross" ? `cross join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)}` : `${join.kind} join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)} on ${renderExpression(join.on, state, dialect)}`).join(" ");
+        const joinSources = updateAst.joins.map((join) => join.kind === "cross" ? `cross join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)}` : `${join.kind} join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)} on ${renderExpression2(join.on, state, dialect)}`).join(" ");
         const targetList = [
           ...targets.map((entry) => renderSourceReference(entry.source, entry.tableName, entry.baseTableName, state, dialect)),
           ...extraSources.length > 0 ? [extraSources] : []
@@ -4452,18 +4386,19 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       }
       const whereParts = [
         ...dialect.name === "postgres" ? renderJoinPredicatesForMutation(updateAst.joins, state, dialect) : [],
-        ...updateAst.where.map((entry) => renderExpression(entry.predicate, state, dialect))
+        ...updateAst.where.map((entry) => renderExpression2(entry.predicate, state, dialect))
       ];
       if (whereParts.length > 0) {
         sql += ` where ${whereParts.join(" and ")}`;
       }
       if (dialect.name === "mysql" && updateAst.orderBy.length > 0) {
-        sql += ` order by ${updateAst.orderBy.map((entry) => `${renderExpression(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`;
+        sql += ` order by ${updateAst.orderBy.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`;
       }
       if (dialect.name === "mysql" && updateAst.limit) {
-        sql += ` limit ${renderExpression(updateAst.limit, state, dialect)}`;
+        sql += ` limit ${renderExpression2(updateAst.limit, state, dialect)}`;
       }
-      const returning = renderSelectionList(updateAst.select, state, dialect, false);
+      assertSupportedMutationReturning(dialect, updateAst.select);
+      const returning = renderSelectionList(updateAst.select, state, dialect);
       projections = returning.projections;
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`;
@@ -4472,31 +4407,18 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
     }
     case "delete": {
       const deleteAst = ast;
-      if (deleteAst.distinct) {
-        throw new Error("distinct(...) is not supported for delete statements");
-      }
-      assertNoGroupedMutationClauses(deleteAst, "delete");
-      if (deleteAst.orderBy.length > 0 && dialect.name === "postgres") {
-        throw new Error("orderBy(...) is not supported for delete statements");
-      }
-      if (deleteAst.limit && dialect.name === "postgres") {
-        throw new Error("limit(...) is not supported for delete statements");
-      }
-      if (deleteAst.offset) {
-        throw new Error("offset(...) is not supported for delete statements");
-      }
-      if (deleteAst.lock) {
-        throw new Error("lock(...) is not supported for delete statements");
-      }
       const targetSource = deleteAst.target;
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect);
       const targets = deleteAst.targets ?? [targetSource];
+      if (dialect.name === "standard" && (targets.length > 1 || deleteAst.joins.length > 0)) {
+        throw new Error("Unsupported standard joined mutation");
+      }
       if (dialect.name === "mysql") {
         const modifiers = renderMysqlMutationLock(deleteAst.lock, "delete");
         const hasJoinedSources = deleteAst.joins.length > 0 || targets.length > 1;
         const targetList = renderDeleteTargets(targets, dialect);
         const fromSources = targets.map((entry) => renderSourceReference(entry.source, entry.tableName, entry.baseTableName, state, dialect)).join(", ");
-        const joinSources = deleteAst.joins.map((join) => join.kind === "cross" ? `cross join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)}` : `${join.kind} join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)} on ${renderExpression(join.on, state, dialect)}`).join(" ");
+        const joinSources = deleteAst.joins.map((join) => join.kind === "cross" ? `cross join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)}` : `${join.kind} join ${renderSourceReference(join.source, join.tableName, join.baseTableName, state, dialect)} on ${renderExpression2(join.on, state, dialect)}`).join(" ");
         sql = hasJoinedSources ? `delete${modifiers} ${targetList} from ${fromSources}${joinSources.length > 0 ? ` ${joinSources}` : ""}` : `delete${modifiers} from ${fromSources}`;
       } else {
         sql = `delete from ${target}`;
@@ -4506,18 +4428,19 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       }
       const whereParts = [
         ...dialect.name === "postgres" ? renderJoinPredicatesForMutation(deleteAst.joins, state, dialect) : [],
-        ...deleteAst.where.map((entry) => renderExpression(entry.predicate, state, dialect))
+        ...deleteAst.where.map((entry) => renderExpression2(entry.predicate, state, dialect))
       ];
       if (whereParts.length > 0) {
         sql += ` where ${whereParts.join(" and ")}`;
       }
       if (dialect.name === "mysql" && deleteAst.orderBy.length > 0) {
-        sql += ` order by ${deleteAst.orderBy.map((entry) => `${renderExpression(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`;
+        sql += ` order by ${deleteAst.orderBy.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`;
       }
       if (dialect.name === "mysql" && deleteAst.limit) {
-        sql += ` limit ${renderExpression(deleteAst.limit, state, dialect)}`;
+        sql += ` limit ${renderExpression2(deleteAst.limit, state, dialect)}`;
       }
-      const returning = renderSelectionList(deleteAst.select, state, dialect, false);
+      assertSupportedMutationReturning(dialect, deleteAst.select);
+      const returning = renderSelectionList(deleteAst.select, state, dialect);
       projections = returning.projections;
       if (returning.sql.length > 0) {
         sql += ` returning ${returning.sql}`;
@@ -4526,14 +4449,18 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
     }
     case "truncate": {
       const truncateAst = ast;
-      assertNoStatementQueryClauses(truncateAst, "truncate");
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard truncate statement");
+      }
       const truncate = expectTruncateClause(truncateAst.truncate);
       const targetSource = truncateAst.target;
+      const restartIdentity = truncate.restartIdentity;
+      const cascade = truncate.cascade;
       sql = `truncate table ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
-      if (truncate.restartIdentity) {
+      if (restartIdentity) {
         sql += " restart identity";
       }
-      if (truncate.cascade) {
+      if (cascade) {
         sql += " cascade";
       }
       break;
@@ -4545,42 +4472,27 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
       const mergeAst = ast;
       const targetSource = mergeAst.target;
       const usingSource = mergeAst.using;
-      const merge = mergeAst.merge;
-      if (merge.kind !== "merge") {
-        throw new Error("Unsupported merge statement kind");
-      }
-      if (Object.keys(mergeAst.select).length > 0) {
-        throw new Error("returning(...) is not supported for merge statements");
-      }
-      if (!merge.whenMatched && !merge.whenNotMatched) {
-        throw new Error("merge statements require at least one action");
-      }
-      sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression(merge.on, state, dialect)}`;
-      if (merge.whenMatched) {
-        assertMergeActionKind(merge.whenMatched.kind, ["update", "delete"]);
+      const merge2 = mergeAst.merge;
+      sql = `merge into ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)} using ${renderSourceReference(usingSource.source, usingSource.tableName, usingSource.baseTableName, state, dialect)} on ${renderExpression2(merge2.on, state, dialect)}`;
+      if (merge2.whenMatched) {
+        const matchedKind = merge2.whenMatched.kind === "delete" ? "delete" : "update";
         sql += " when matched";
-        if (merge.whenMatched.predicate) {
-          sql += ` and ${renderExpression(merge.whenMatched.predicate, state, dialect)}`;
+        if (merge2.whenMatched.predicate) {
+          sql += ` and ${renderExpression2(merge2.whenMatched.predicate, state, dialect)}`;
         }
-        if (merge.whenMatched.kind === "delete") {
+        if (matchedKind === "delete") {
           sql += " then delete";
         } else {
-          if (merge.whenMatched.values.length === 0) {
-            throw new Error("merge update actions require at least one assignment");
-          }
-          sql += ` then update set ${merge.whenMatched.values.map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ")}`;
+          const matchedUpdate = merge2.whenMatched;
+          sql += ` then update set ${matchedUpdate.values.map((entry) => `${quoteColumn(entry.columnName, state, dialect, targetSource.tableName)} = ${renderExpression2(entry.value, state, dialect)}`).join(", ")}`;
         }
       }
-      if (merge.whenNotMatched) {
-        assertMergeActionKind(merge.whenNotMatched.kind, ["insert"]);
+      if (merge2.whenNotMatched) {
         sql += " when not matched";
-        if (merge.whenNotMatched.predicate) {
-          sql += ` and ${renderExpression(merge.whenNotMatched.predicate, state, dialect)}`;
-        }
-        if (merge.whenNotMatched.values.length === 0) {
-          throw new Error("merge insert actions require at least one value");
+        if (merge2.whenNotMatched.predicate) {
+          sql += ` and ${renderExpression2(merge2.whenNotMatched.predicate, state, dialect)}`;
         }
-        sql += ` then insert (${merge.whenNotMatched.values.map((entry) => dialect.quoteIdentifier(entry.columnName)).join(", ")}) values (${merge.whenNotMatched.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`;
+        sql += ` then insert (${merge2.whenNotMatched.values.map((entry) => quoteColumn(entry.columnName, state, dialect, targetSource.tableName)).join(", ")}) values (${merge2.whenNotMatched.values.map((entry) => renderExpression2(entry.value, state, dialect)).join(", ")})`;
       }
       break;
     }
@@ -4590,38 +4502,41 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
     case "savepoint":
     case "rollbackTo":
     case "releaseSavepoint": {
-      assertNoStatementQueryClauses(ast, ast.kind);
       sql = renderTransactionClause(ast.transaction, dialect);
       break;
     }
     case "createTable": {
       const createTableAst = ast;
-      assertNoStatementQueryClauses(createTableAst, "createTable");
       const ddl = expectDdlClauseKind(createTableAst.ddl, "createTable");
       sql = renderCreateTableSql(createTableAst.target, state, dialect, ddl.ifNotExists);
       break;
     }
     case "dropTable": {
       const dropTableAst = ast;
-      assertNoStatementQueryClauses(dropTableAst, "dropTable");
       const ddl = expectDdlClauseKind(dropTableAst.ddl, "dropTable");
-      sql = `drop table${ddl.ifExists ? " if exists" : ""} ${renderSourceReference(dropTableAst.target.source, dropTableAst.target.tableName, dropTableAst.target.baseTableName, state, dialect)}`;
+      const ifExists = normalizeStatementFlag(ddl.ifExists);
+      if (dialect.name !== "postgres" && ifExists) {
+        throw new Error(`Unsupported ${dialect.name} drop table options`);
+      }
+      sql = `drop table${ifExists ? " if exists" : ""} ${renderSourceReference(dropTableAst.target.source, dropTableAst.target.tableName, dropTableAst.target.baseTableName, state, dialect)}`;
       break;
     }
     case "createIndex": {
       const createIndexAst = ast;
-      assertNoStatementQueryClauses(createIndexAst, "createIndex");
       sql = renderCreateIndexSql(createIndexAst.target, expectDdlClauseKind(createIndexAst.ddl, "createIndex"), state, dialect);
       break;
     }
     case "dropIndex": {
       const dropIndexAst = ast;
-      assertNoStatementQueryClauses(dropIndexAst, "dropIndex");
       sql = renderDropIndexSql(dropIndexAst.target, expectDdlClauseKind(dropIndexAst.ddl, "dropIndex"), state, dialect);
       break;
     }
-    default:
-      throw new Error("Unsupported query statement kind");
+    default: {
+      if (ast.transaction !== undefined) {
+        sql = renderTransactionClause(ast.transaction, dialect);
+      }
+      break;
+    }
   }
   if (state.ctes.length === 0 || options2.emitCtes === false) {
     return {
@@ -4636,7 +4551,7 @@ var renderQueryAst = (ast, state, dialect, options2 = {}) => {
 };
 var renderSourceReference = (source, tableName, baseTableName, state, dialect) => {
   const renderSelectRows = (rows, columnNames) => {
-    const renderedRows = rows.map((row) => `select ${columnNames.map((columnName) => `${renderExpression(row[columnName], state, dialect)} as ${dialect.quoteIdentifier(columnName)}`).join(", ")}`);
+    const renderedRows = rows.map((row) => `select ${columnNames.map((columnName) => `${renderExpression2(row[columnName], state, dialect)} as ${dialect.quoteIdentifier(columnName)}`).join(", ")}`);
     return `(${renderedRows.join(" union all ")}) as ${dialect.quoteIdentifier(tableName)}(${columnNames.map((columnName) => dialect.quoteIdentifier(columnName)).join(", ")})`;
   };
   const renderUnnestRows = (arrays, columnNames) => {
@@ -4653,7 +4568,7 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
     if (!state.cteNames.has(cte.name)) {
       state.cteNames.add(cte.name);
       state.cteSources.set(cte.name, cte.plan);
-      const rendered = renderQueryAst(getAst(cte.plan), state, dialect, { emitCtes: false });
+      const rendered = renderQueryAst2(getAst(cte.plan), state, dialect, { emitCtes: false });
       state.ctes.push({
         name: cte.name,
         sql: rendered.sql,
@@ -4665,11 +4580,14 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "derived") {
     const derived = source;
     if (!state.cteNames.has(derived.name)) {}
-    return `(${renderQueryAst(getAst(derived.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(derived.name)}`;
+    return `(${renderQueryAst2(getAst(derived.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(derived.name)}`;
   }
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "lateral") {
     const lateral = source;
-    return `lateral (${renderQueryAst(getAst(lateral.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`;
+    if (dialect.name === "standard") {
+      throw new Error("Unsupported standard lateral source");
+    }
+    return `lateral (${renderQueryAst2(getAst(lateral.plan), nestedRenderState(state), dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`;
   }
   if (typeof source === "object" && source !== null && source.kind === "values") {
     const values = source;
@@ -4684,168 +4602,219 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
     if (dialect.name !== "postgres") {
       throw new Error("Unsupported table function source for SQL rendering");
     }
+    const functionName = renderFunctionName(tableFunction.functionName);
     const columnNames = Object.keys(tableFunction.columns);
-    return `${tableFunction.functionName}(${tableFunction.args.map((arg) => renderExpression(arg, state, dialect)).join(", ")}) as ${dialect.quoteIdentifier(tableFunction.name)}(${columnNames.map((columnName) => dialect.quoteIdentifier(columnName)).join(", ")})`;
+    return `${functionName}(${tableFunction.args.map((arg) => renderExpression2(arg, state, dialect)).join(", ")}) as ${dialect.quoteIdentifier(tableFunction.name)}(${columnNames.map((columnName) => dialect.quoteIdentifier(columnName)).join(", ")})`;
   }
-  const schemaName = typeof source === "object" && source !== null && TypeId4 in source ? source[TypeId4].schemaName : undefined;
-  return dialect.renderTableReference(tableName, baseTableName, schemaName);
+  const schemaName = typeof source === "object" && source !== null && TypeId6 in source ? casedSchemaName(source, state) : undefined;
+  if (typeof source === "object" && source !== null && TypeId6 in source) {
+    const table = source;
+    const renderedBaseName = casedTableName(table, state);
+    const renderedTableName = table[TypeId6].kind === "alias" ? tableName : renderedBaseName;
+    return dialect.renderTableReference(renderedTableName, renderedBaseName, schemaName);
+  }
+  return dialect.renderTableReference(applyCategory(state.casing, "tables", tableName), applyCategory(state.casing, "tables", baseTableName), schemaName);
 };
 var renderSubqueryExpressionPlan = (plan, state, dialect) => {
   const statement = getQueryState(plan).statement;
   if (statement !== "select" && statement !== "set") {
     throw new Error("subquery expressions only accept select-like query plans");
   }
-  return renderQueryAst(getAst(plan), state, dialect).sql;
+  return renderQueryAst2(getAst(plan), state, dialect).sql;
 };
-var renderExpression = (expression, state, dialect) => {
+var renderExpression2 = (expression, state, dialect) => {
   const rawAst = expression[TypeId3];
   const jsonSql = renderJsonExpression(expression, rawAst, state, dialect);
   if (jsonSql !== undefined) {
     return jsonSql;
   }
   const ast = rawAst;
-  const renderComparisonOperator = (operator) => operator === "eq" ? "=" : operator === "neq" ? "<>" : operator === "lt" ? "<" : operator === "lte" ? "<=" : operator === "gt" ? ">" : ">=";
+  const renderComparisonOperator = (operator) => ({
+    eq: "=",
+    neq: "<>",
+    lt: "<",
+    lte: "<=",
+    gt: ">",
+    gte: ">="
+  })[operator];
+  const renderCollation = (collation) => {
+    return collation.map((segment) => dialect.quoteIdentifier(segment)).join(".");
+  };
   switch (ast.kind) {
     case "column":
-      return state.rowLocalColumns || ast.tableName.length === 0 ? dialect.quoteIdentifier(ast.columnName) : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`;
+      return state.rowLocalColumns || ast.tableName.length === 0 ? quoteColumn(ast.columnName, state, dialect, ast.tableName) : `${dialect.quoteIdentifier(casedTableReferenceName(ast.tableName, state))}.${quoteColumn(ast.columnName, state, dialect, ast.tableName)}`;
     case "literal":
       if (typeof ast.value === "number" && !Number.isFinite(ast.value)) {
         throw new Error("Expected a finite numeric value");
       }
       return dialect.renderLiteral(ast.value, state, expression[TypeId2]);
     case "excluded":
-      return dialect.name === "mysql" ? `values(${dialect.quoteIdentifier(ast.columnName)})` : `excluded.${dialect.quoteIdentifier(ast.columnName)}`;
+      if (state.allowExcluded !== true) {
+        throw new Error("excluded(...) is only supported inside insert conflict handlers");
+      }
+      return dialect.name === "mysql" ? `values(${quoteColumn(ast.columnName, state, dialect)})` : `excluded.${quoteColumn(ast.columnName, state, dialect)}`;
     case "cast":
-      return `cast(${renderExpression(ast.value, state, dialect)} as ${renderCastType(dialect, ast.target)})`;
+      return `cast(${renderExpression2(expectValueExpression("cast", ast.value), state, dialect)} as ${renderCastType(dialect, ast.target)})`;
     case "collate":
-      return `(${renderExpression(ast.value, state, dialect)} collate ${ast.collation.map((segment) => dialect.quoteIdentifier(segment)).join(".")})`;
+      return `(${renderExpression2(expectValueExpression("collate", ast.value), state, dialect)} collate ${renderCollation(ast.collation)})`;
     case "function":
-      return renderFunctionCall(ast.name, Array.isArray(ast.args) ? ast.args : [], state, dialect);
+      return renderFunctionCall(ast.name, ast.args, state, dialect);
     case "eq":
-      return `(${renderExpression(ast.left, state, dialect)} = ${renderExpression(ast.right, state, dialect)})`;
+      return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect);
     case "neq":
-      return `(${renderExpression(ast.left, state, dialect)} <> ${renderExpression(ast.right, state, dialect)})`;
+      return renderBinaryExpression("neq", "<>", ast.left, ast.right, state, dialect);
     case "lt":
-      return `(${renderExpression(ast.left, state, dialect)} < ${renderExpression(ast.right, state, dialect)})`;
+      return renderBinaryExpression("lt", "<", ast.left, ast.right, state, dialect);
     case "lte":
-      return `(${renderExpression(ast.left, state, dialect)} <= ${renderExpression(ast.right, state, dialect)})`;
+      return renderBinaryExpression("lte", "<=", ast.left, ast.right, state, dialect);
     case "gt":
-      return `(${renderExpression(ast.left, state, dialect)} > ${renderExpression(ast.right, state, dialect)})`;
+      return renderBinaryExpression("gt", ">", ast.left, ast.right, state, dialect);
     case "gte":
-      return `(${renderExpression(ast.left, state, dialect)} >= ${renderExpression(ast.right, state, dialect)})`;
+      return renderBinaryExpression("gte", ">=", ast.left, ast.right, state, dialect);
     case "like":
-      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":
-      return dialect.name === "mysql" ? `(${renderExpression(ast.left, state, dialect)} <=> ${renderExpression(ast.right, state, dialect)})` : `(${renderExpression(ast.left, state, dialect)} is not distinct from ${renderExpression(ast.right, state, dialect)})`;
-    case "contains":
+      return renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect);
+    case "ilike": {
+      const [left, right] = expectBinaryExpressions("ilike", ast.left, ast.right);
+      return dialect.name === "postgres" ? `(${renderExpression2(left, state, dialect)} ilike ${renderExpression2(right, state, dialect)})` : `(lower(${renderExpression2(left, state, dialect)}) like lower(${renderExpression2(right, state, dialect)}))`;
+    }
+    case "regexMatch": {
+      const [left, right] = expectBinaryExpressions("regexMatch", ast.left, ast.right);
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard regular-expression predicates");
+      }
+      return dialect.name === "postgres" ? `(${renderExpression2(left, state, dialect)} ~ ${renderExpression2(right, state, dialect)})` : `(${renderExpression2(left, state, dialect)} regexp ${renderExpression2(right, state, dialect)})`;
+    }
+    case "regexIMatch": {
+      const [left, right] = expectBinaryExpressions("regexIMatch", ast.left, ast.right);
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard regular-expression predicates");
+      }
+      return dialect.name === "postgres" ? `(${renderExpression2(left, state, dialect)} ~* ${renderExpression2(right, state, dialect)})` : `(${renderExpression2(left, state, dialect)} regexp ${renderExpression2(right, state, dialect)})`;
+    }
+    case "regexNotMatch": {
+      const [left, right] = expectBinaryExpressions("regexNotMatch", ast.left, ast.right);
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard regular-expression predicates");
+      }
+      return dialect.name === "postgres" ? `(${renderExpression2(left, state, dialect)} !~ ${renderExpression2(right, state, dialect)})` : `(${renderExpression2(left, state, dialect)} not regexp ${renderExpression2(right, state, dialect)})`;
+    }
+    case "regexNotIMatch": {
+      const [left, right] = expectBinaryExpressions("regexNotIMatch", ast.left, ast.right);
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard regular-expression predicates");
+      }
+      return dialect.name === "postgres" ? `(${renderExpression2(left, state, dialect)} !~* ${renderExpression2(right, state, dialect)})` : `(${renderExpression2(left, state, dialect)} not regexp ${renderExpression2(right, state, dialect)})`;
+    }
+    case "isDistinctFrom": {
+      const [left, right] = expectBinaryExpressions("isDistinctFrom", ast.left, ast.right);
+      return dialect.name === "mysql" ? `(not (${renderExpression2(left, state, dialect)} <=> ${renderExpression2(right, state, dialect)}))` : `(${renderExpression2(left, state, dialect)} is distinct from ${renderExpression2(right, state, dialect)})`;
+    }
+    case "isNotDistinctFrom": {
+      const [left, right] = expectBinaryExpressions("isNotDistinctFrom", ast.left, ast.right);
+      return dialect.name === "mysql" ? `(${renderExpression2(left, state, dialect)} <=> ${renderExpression2(right, state, dialect)})` : `(${renderExpression2(left, state, dialect)} is not distinct from ${renderExpression2(right, state, dialect)})`;
+    }
+    case "contains": {
+      const [leftExpression, rightExpression] = expectBinaryExpressions("contains", ast.left, ast.right);
       if (dialect.name === "postgres") {
-        assertCompatiblePostgresRangeOperands(ast.left, ast.right);
-        const left = isJsonExpression(ast.left) ? renderPostgresJsonValue(ast.left, state, dialect) : renderExpression(ast.left, state, dialect);
-        const right = isJsonExpression(ast.right) ? renderPostgresJsonValue(ast.right, state, dialect) : renderExpression(ast.right, state, dialect);
+        assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
+        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} @> ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_contains(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`;
+      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+        return `json_contains(${renderExpression2(leftExpression, state, dialect)}, ${renderExpression2(rightExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
-    case "containedBy":
+    }
+    case "containedBy": {
+      const [leftExpression, rightExpression] = expectBinaryExpressions("containedBy", ast.left, ast.right);
       if (dialect.name === "postgres") {
-        assertCompatiblePostgresRangeOperands(ast.left, ast.right);
-        const left = isJsonExpression(ast.left) ? renderPostgresJsonValue(ast.left, state, dialect) : renderExpression(ast.left, state, dialect);
-        const right = isJsonExpression(ast.right) ? renderPostgresJsonValue(ast.right, state, dialect) : renderExpression(ast.right, state, dialect);
+        assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
+        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} <@ ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_contains(${renderExpression(ast.right, state, dialect)}, ${renderExpression(ast.left, state, dialect)})`;
+      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+        return `json_contains(${renderExpression2(rightExpression, state, dialect)}, ${renderExpression2(leftExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
-    case "overlaps":
+    }
+    case "overlaps": {
+      const [leftExpression, rightExpression] = expectBinaryExpressions("overlaps", ast.left, ast.right);
       if (dialect.name === "postgres") {
-        assertCompatiblePostgresRangeOperands(ast.left, ast.right);
-        const left = isJsonExpression(ast.left) ? renderPostgresJsonValue(ast.left, state, dialect) : renderExpression(ast.left, state, dialect);
-        const right = isJsonExpression(ast.right) ? renderPostgresJsonValue(ast.right, state, dialect) : renderExpression(ast.right, state, dialect);
+        assertCompatiblePostgresRangeOperands(leftExpression, rightExpression);
+        const left = isJsonExpression(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} && ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(ast.left) && isJsonExpression(ast.right)) {
-        return `json_overlaps(${renderExpression(ast.left, state, dialect)}, ${renderExpression(ast.right, state, dialect)})`;
+      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+        return `json_overlaps(${renderExpression2(leftExpression, state, dialect)}, ${renderExpression2(rightExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
+    }
     case "isNull":
-      return `(${renderExpression(ast.value, state, dialect)} is null)`;
+      return `(${renderExpression2(expectValueExpression("isNull", ast.value), state, dialect)} is null)`;
     case "isNotNull":
-      return `(${renderExpression(ast.value, state, dialect)} is not null)`;
+      return `(${renderExpression2(expectValueExpression("isNotNull", ast.value), state, dialect)} is not null)`;
     case "not":
-      return `(not ${renderExpression(ast.value, state, dialect)})`;
+      return `(not ${renderExpression2(expectValueExpression("not", ast.value), state, dialect)})`;
     case "upper":
-      return `upper(${renderExpression(ast.value, state, dialect)})`;
+      return `upper(${renderExpression2(expectValueExpression("upper", ast.value), state, dialect)})`;
     case "lower":
-      return `lower(${renderExpression(ast.value, state, dialect)})`;
+      return `lower(${renderExpression2(expectValueExpression("lower", ast.value), state, dialect)})`;
     case "count":
-      return `count(${renderExpression(ast.value, state, dialect)})`;
+      return `count(${renderExpression2(expectValueExpression("count", ast.value), state, dialect)})`;
     case "max":
-      return `max(${renderExpression(ast.value, state, dialect)})`;
+      return `max(${renderExpression2(expectValueExpression("max", ast.value), state, dialect)})`;
     case "min":
-      return `min(${renderExpression(ast.value, state, dialect)})`;
+      return `min(${renderExpression2(expectValueExpression("min", ast.value), state, dialect)})`;
     case "and":
-      if (ast.values.length === 0) {
-        throw new Error("and(...) requires at least one predicate");
-      }
-      return `(${ast.values.map((value) => renderExpression(value, state, dialect)).join(" and ")})`;
+      return `(${ast.values.map((value) => renderExpression2(value, state, dialect)).join(" and ")})`;
     case "or":
-      if (ast.values.length === 0) {
-        throw new Error("or(...) requires at least one predicate");
-      }
-      return `(${ast.values.map((value) => renderExpression(value, state, dialect)).join(" or ")})`;
+      return `(${ast.values.map((value) => renderExpression2(value, state, dialect)).join(" or ")})`;
     case "coalesce":
-      return `coalesce(${ast.values.map((value) => renderExpression(value, state, dialect)).join(", ")})`;
+      return `coalesce(${ast.values.map((value) => renderExpression2(value, state, dialect)).join(", ")})`;
     case "in":
-      if (ast.values.length < 2) {
-        throw new Error("in(...) requires at least one candidate value");
-      }
-      return `(${renderExpression(ast.values[0], state, dialect)} in (${ast.values.slice(1).map((value) => renderExpression(value, state, dialect)).join(", ")}))`;
+      return `(${renderExpression2(ast.values[0], state, dialect)} in (${ast.values.slice(1).map((value) => renderExpression2(value, state, dialect)).join(", ")}))`;
     case "notIn":
-      if (ast.values.length < 2) {
-        throw new Error("notIn(...) requires at least one candidate value");
-      }
-      return `(${renderExpression(ast.values[0], state, dialect)} not in (${ast.values.slice(1).map((value) => renderExpression(value, state, dialect)).join(", ")}))`;
+      return `(${renderExpression2(ast.values[0], state, dialect)} not in (${ast.values.slice(1).map((value) => renderExpression2(value, state, dialect)).join(", ")}))`;
     case "between":
-      return `(${renderExpression(ast.values[0], state, dialect)} between ${renderExpression(ast.values[1], state, dialect)} and ${renderExpression(ast.values[2], state, dialect)})`;
+      return `(${renderExpression2(ast.values[0], state, dialect)} between ${renderExpression2(ast.values[1], state, dialect)} and ${renderExpression2(ast.values[2], state, dialect)})`;
     case "concat":
-      return dialect.renderConcat(ast.values.map((value) => renderExpression(value, state, dialect)));
+      return dialect.renderConcat(ast.values.map((value) => renderExpression2(value, state, dialect)));
     case "case":
-      return `case ${ast.branches.map((branch) => `when ${renderExpression(branch.when, state, dialect)} then ${renderExpression(branch.then, state, dialect)}`).join(" ")} else ${renderExpression(ast.else, state, dialect)} end`;
+      return `case ${ast.branches.map((branch) => `when ${renderExpression2(branch.when, state, dialect)} then ${renderExpression2(branch.then, state, dialect)}`).join(" ")} else ${renderExpression2(ast.else, state, dialect)} end`;
     case "exists":
       return `exists (${renderSubqueryExpressionPlan(ast.plan, state, dialect)})`;
     case "scalarSubquery":
       return `(${renderSubqueryExpressionPlan(ast.plan, state, dialect)})`;
     case "inSubquery":
-      return `(${renderExpression(ast.left, state, dialect)} in (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
-    case "comparisonAny":
-      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} any (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
-    case "comparisonAll":
-      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} all (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
-    case "window": {
-      if (!Array.isArray(ast.partitionBy) || !Array.isArray(ast.orderBy) || typeof ast.function !== "string") {
-        break;
+      return `(${renderExpression2(expectValueExpression("inSubquery", ast.left), state, dialect)} in (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
+    case "comparisonAny": {
+      const left = expectValueExpression("compareAny", ast.left);
+      const operator = renderComparisonOperator(ast.operator);
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard quantified comparison");
+      }
+      return `(${renderExpression2(left, state, dialect)} ${operator} any (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
+    }
+    case "comparisonAll": {
+      const left = expectValueExpression("compareAll", ast.left);
+      const operator = renderComparisonOperator(ast.operator);
+      if (dialect.name === "standard") {
+        throw new Error("Unsupported standard quantified comparison");
       }
+      return `(${renderExpression2(left, state, dialect)} ${operator} all (${renderSubqueryExpressionPlan(ast.plan, state, dialect)}))`;
+    }
+    case "window": {
+      const partitionBy = ast.partitionBy;
+      const orderBy = ast.orderBy;
       const clauses = [];
-      if (ast.partitionBy.length > 0) {
-        clauses.push(`partition by ${ast.partitionBy.map((value) => renderExpression(value, state, dialect)).join(", ")}`);
+      if (partitionBy.length > 0) {
+        clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
       }
-      if (ast.orderBy.length > 0) {
-        clauses.push(`order by ${ast.orderBy.map((entry) => `${renderExpression(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
+      if (orderBy.length > 0) {
+        clauses.push(`order by ${orderBy.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
       }
       const specification = clauses.join(" ");
       switch (ast.function) {
@@ -4856,7 +4825,7 @@ var renderExpression = (expression, state, dialect) => {
         case "denseRank":
           return `dense_rank() over (${specification})`;
         case "over":
-          return `${renderExpression(ast.value, state, dialect)} over (${specification})`;
+          return `${renderExpression2(ast.value, state, dialect)} over (${specification})`;
       }
       break;
     }
@@ -4864,12 +4833,41 @@ var renderExpression = (expression, state, dialect) => {
   throw new Error("Unsupported expression for SQL rendering");
 };
 
-// src/postgres/internal/schema-ddl.ts
-import { parse as parse2, toSql as toSql2 } from "pgsql-ast-parser";
+// src/standard/dialect.ts
+var quoteIdentifier = quoteDoubleQuotedIdentifier;
+var renderLiteral = (value, state, context = {}) => {
+  const driverValue = toDriverValue(value, {
+    dialect: "standard",
+    valueMappings: state.valueMappings,
+    ...context
+  });
+  if (driverValue === null) {
+    return "null";
+  }
+  if (typeof driverValue === "boolean") {
+    return driverValue ? "true" : "false";
+  }
+  state.params.push(driverValue);
+  return "?";
+};
+var standardDialect = {
+  name: "standard",
+  quoteIdentifier,
+  renderLiteral,
+  renderTableReference(tableName, baseTableName, schemaName) {
+    const renderedBase = schemaName && schemaName !== "public" ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}` : quoteIdentifier(baseTableName);
+    return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier(tableName)}`;
+  },
+  renderConcat(values) {
+    return `(${values.join(" || ")})`;
+  },
+  renderQueryAst: renderQueryAst2,
+  renderExpression: renderExpression2
+};
 
 // src/postgres/internal/dialect.ts
-var quoteIdentifier = (value) => `"${value.replaceAll('"', '""')}"`;
-var renderLiteral = (value, state, context = {}) => {
+var quoteIdentifier2 = quoteDoubleQuotedIdentifier;
+var renderLiteral2 = (value, state, context = {}) => {
   const driverValue = toDriverValue(value, {
     dialect: "postgres",
     valueMappings: state.valueMappings,
@@ -4885,16 +4883,19 @@ var renderLiteral = (value, state, context = {}) => {
   return `$${state.params.length}`;
 };
 var postgresDialect = {
+  ...standardDialect,
   name: "postgres",
-  quoteIdentifier,
-  renderLiteral,
+  quoteIdentifier: quoteIdentifier2,
+  renderLiteral: renderLiteral2,
   renderTableReference(tableName, baseTableName, schemaName) {
-    const renderedBase = schemaName ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}` : quoteIdentifier(baseTableName);
-    return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier(tableName)}`;
+    const renderedBase = schemaName && schemaName !== "public" ? `${quoteIdentifier2(schemaName)}.${quoteIdentifier2(baseTableName)}` : quoteIdentifier2(baseTableName);
+    return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier2(tableName)}`;
   },
   renderConcat(values) {
     return `(${values.join(" || ")})`;
-  }
+  },
+  renderQueryAst: renderQueryAst2,
+  renderExpression: renderExpression2
 };
 
 // src/postgres/internal/schema-ddl.ts
@@ -4912,17 +4913,22 @@ var inlineLiteralDialect = {
       return String(value);
     }
     if (value instanceof Date) {
+      if (Number.isNaN(value.getTime())) {
+        throw new Error("Expected a valid Date value");
+      }
       return escapeString(value.toISOString());
     }
     return escapeString(String(value));
   }
 };
-var renderDdlExpressionSql = (expression) => isSchemaExpression(expression) ? render(expression) : renderExpression(expression, {
+var makeExpressionState = (state = {}) => ({
+  ...state,
   params: [],
   ctes: [],
   cteNames: new Set,
   cteSources: new Map
-}, inlineLiteralDialect);
+});
+var renderDdlExpressionSql = (expression, state) => isSchemaExpression(expression) ? render(expression) : renderExpression(expression, makeExpressionState(state), inlineLiteralDialect);
 var stripRedundantOuterParens = (value) => {
   let current = value.trim();
   while (current.startsWith("(") && current.endsWith(")")) {
@@ -4962,8 +4968,8 @@ var stripRedundantOuterParens = (value) => {
   return current;
 };
 var canonicalizeDdlExpressionSql = (value) => stripRedundantOuterParens(value.trim().replace(/\s+/g, " ").replace(/"[^"]+"\./g, "").replace(/"([A-Za-z_][A-Za-z0-9_]*)"/g, "$1").replace(/\bCOLLATE\b/g, "collate").replace(/cast\(((?:'(?:[^']|'')*'|"[^"]+"|[a-zA-Z_][a-zA-Z0-9_]*|\([^()]+\))) as ([^)]+)\)/gi, (_, expression, target) => `${expression}::${target.trim()}`));
-var normalizeDdlExpressionSql = (expression) => {
-  const rendered = renderDdlExpressionSql(expression);
+var normalizeDdlExpressionSql = (expression, state) => {
+  const rendered = renderDdlExpressionSql(expression, state);
   try {
     return canonicalizeDdlExpressionSql(toSql2.expr(parse2(rendered, "expr")));
   } catch {
@@ -4977,8 +4983,8 @@ import { pipeArguments as pipeArguments5 } from "effect/Pipeable";
 var EnumTypeId = Symbol.for("effect-qb/SchemaManagement/Enum");
 var SequenceTypeId = Symbol.for("effect-qb/SchemaManagement/Sequence");
 var safeUnquotedIdentifier = /^[a-z_][a-z0-9_$]*$/;
-var quoteIdentifier2 = (value) => `"${value.replaceAll('"', '""')}"`;
-var renderIdentifier = (value) => safeUnquotedIdentifier.test(value) ? value : quoteIdentifier2(value);
+var quoteIdentifier3 = (value) => `"${value.replaceAll('"', '""')}"`;
+var renderIdentifier = (value) => safeUnquotedIdentifier.test(value) ? value : quoteIdentifier3(value);
 var renderQualifiedTypeName = (name, schemaName) => schemaName === undefined || schemaName === "public" ? renderIdentifier(name) : `${renderIdentifier(schemaName)}.${renderIdentifier(name)}`;
 var EnumProto = {
   pipe() {
@@ -4995,7 +5001,11 @@ var EnumProto = {
     };
   },
   column() {
-    const values = this.values.map((value) => Schema6.Literal(value));
+    const [first, ...rest] = this.values;
+    const values = [
+      Schema6.Literal(first),
+      ...rest.map((value) => Schema6.Literal(value))
+    ];
     return makeColumnDefinition(values.length === 1 ? values[0] : Schema6.Union(...values), {
       dbType: this.type(),
       nullable: false,
@@ -5049,17 +5059,123 @@ function sequence(name, schemaName) {
 var isSequenceDefinition = (value) => typeof value === "object" && value !== null && (SequenceTypeId in value);
 
 // src/postgres/internal/schema-model.ts
-var isTableDefinition = (value) => value !== null && (typeof value === "object" || typeof value === "function") && (TypeId4 in value);
+var isTableDefinition = (value) => value !== null && (typeof value === "object" || typeof value === "function") && (TypeId6 in value);
 var isEnumDefinition = (value) => typeof value === "object" && value !== null && (EnumTypeId in value);
+var applyCasing = (casing, category, name) => applyCategory(casing, category, name);
+var mapColumnList = (columns, casing) => !Array.isArray(columns) ? columns : columns.length === 0 ? columns : [
+  mapCasedValue(columns[0], casing, "columns"),
+  ...columns.slice(1).map((column) => mapCasedValue(column, casing, "columns"))
+];
+var expressionStateForTable = (state, tableName, columns, casing) => ({
+  casing,
+  rowLocalColumns: true,
+  sourceNames: new Map([
+    [state.name, { tableName, columns }],
+    [state.baseName, { tableName, columns }]
+  ])
+});
+var mapDdlExpression = (expression, state) => fromSql(normalizeDdlExpressionSql(expression, state));
+function mapOptionName(name, casing, category) {
+  return typeof name === "string" ? applyCasing(casing, category, name) : name;
+}
+function mapCasedValue(value, casing, category) {
+  return typeof value === "string" ? applyCasing(casing, category, value) : value;
+}
+var isDdlExpressionLike = (value) => typeof value === "object" && value !== null && ((TypeId2 in value) || (TypeId4 in value));
+function mapIndexKey(key2, casing, expressionState) {
+  if (typeof key2 !== "object" || key2 === null || !("kind" in key2)) {
+    return key2;
+  }
+  const kind = key2.kind;
+  if (kind === "column") {
+    const column = key2.column;
+    return typeof column === "string" ? {
+      ...key2,
+      column: applyCasing(casing, "columns", column)
+    } : key2;
+  }
+  if (kind === "expression") {
+    const expression = key2.expression;
+    return isDdlExpressionLike(expression) ? {
+      ...key2,
+      expression: mapDdlExpression(expression, expressionState)
+    } : key2;
+  }
+  return key2;
+}
+var mapOption = (option2, casing, expressionState) => {
+  switch (option2.kind) {
+    case "index":
+      return {
+        ...option2,
+        columns: option2.columns === undefined ? undefined : mapColumnList(option2.columns, casing),
+        name: option2.name === undefined ? undefined : mapOptionName(option2.name, casing, "indexes"),
+        include: option2.include === undefined ? undefined : Array.isArray(option2.include) ? option2.include.map((column) => mapCasedValue(column, casing, "columns")) : option2.include,
+        predicate: option2.predicate === undefined ? undefined : isDdlExpressionLike(option2.predicate) ? mapDdlExpression(option2.predicate, expressionState) : option2.predicate,
+        keys: option2.keys === undefined ? undefined : Array.isArray(option2.keys) ? option2.keys.length === 0 ? option2.keys : [
+          mapIndexKey(option2.keys[0], casing, expressionState),
+          ...option2.keys.slice(1).map((key2) => mapIndexKey(key2, casing, expressionState))
+        ] : option2.keys
+      };
+    case "primaryKey":
+      return {
+        ...option2,
+        columns: mapColumnList(option2.columns, casing),
+        name: option2.name === undefined ? undefined : mapOptionName(option2.name, casing, "constraints")
+      };
+    case "unique":
+      return {
+        ...option2,
+        columns: mapColumnList(option2.columns, casing),
+        name: option2.name === undefined ? undefined : mapOptionName(option2.name, casing, "constraints")
+      };
+    case "foreignKey":
+      return {
+        ...option2,
+        columns: mapColumnList(option2.columns, casing),
+        name: option2.name === undefined ? undefined : mapOptionName(option2.name, casing, "constraints"),
+        references: () => {
+          const reference = typeof option2.references === "function" ? option2.references() : option2.references;
+          if (typeof reference !== "object" || reference === null) {
+            return reference;
+          }
+          const referenceCasing2 = reference.casing;
+          return {
+            ...reference,
+            tableName: mapCasedValue(reference.tableName, referenceCasing2, "tables"),
+            schemaName: reference.schemaName === undefined ? undefined : mapCasedValue(reference.schemaName, referenceCasing2, "schemas"),
+            columns: mapColumnList(reference.columns, referenceCasing2),
+            knownColumns: reference.knownColumns === undefined ? undefined : Array.isArray(reference.knownColumns) ? reference.knownColumns.map((column) => mapCasedValue(column, referenceCasing2, "columns")) : reference.knownColumns
+          };
+        }
+      };
+    case "check":
+      return {
+        ...option2,
+        name: mapOptionName(option2.name, casing, "constraints"),
+        predicate: isDdlExpressionLike(option2.predicate) ? mapDdlExpression(option2.predicate, expressionState) : option2.predicate
+      };
+    default:
+      return option2;
+  }
+};
 var toTableModel = (table) => {
-  const state = table[TypeId4];
+  const state = table[TypeId6];
+  const casing = state.casing;
+  const tableName = applyCasing(casing, "tables", state.baseName);
+  const schemaName = state.schemaName === undefined ? undefined : applyCasing(casing, "schemas", state.schemaName);
   const fields = state.fields;
+  const options2 = table[OptionsSymbol];
+  const normalizedOptions = Array.isArray(options2) ? options2 : [options2];
+  validateOptions(state.name, fields, normalizedOptions);
+  const columnNames = new Map(Object.keys(fields).map((name) => [name, applyCasing(casing, "columns", name)]));
+  const expressionState = expressionStateForTable(state, tableName, columnNames, casing);
   const columns = Object.entries(fields).map(([name, column]) => {
     const metadata = column.metadata;
     const enumDefinition = metadata.enum;
     const ddlType = metadata.ddlType ?? metadata.dbType.kind;
     return {
-      name,
+      name: columnNames.get(name) ?? name,
       ddlType,
       dbTypeKind: enumDefinition?.name ?? column.metadata.dbType.kind,
       typeKind: enumDefinition === undefined ? undefined : "e",
@@ -5067,18 +5183,18 @@ var toTableModel = (table) => {
       nullable: column.metadata.nullable,
       hasDefault: column.metadata.hasDefault,
       generated: column.metadata.generated,
-      defaultSql: column.metadata.defaultValue === undefined ? undefined : normalizeDdlExpressionSql(column.metadata.defaultValue),
-      generatedSql: column.metadata.generatedValue === undefined ? undefined : normalizeDdlExpressionSql(column.metadata.generatedValue),
+      defaultSql: column.metadata.defaultValue === undefined ? undefined : normalizeDdlExpressionSql(column.metadata.defaultValue, expressionState),
+      generatedSql: column.metadata.generatedValue === undefined ? undefined : normalizeDdlExpressionSql(column.metadata.generatedValue, expressionState),
       identity: column.metadata.identity,
       column
     };
   });
   return {
     kind: "table",
-    schemaName: state.schemaName,
-    name: state.baseName,
+    schemaName,
+    name: tableName,
     columns,
-    options: table[OptionsSymbol],
+    options: normalizedOptions.map((option2) => typeof option2 === "object" && option2 !== null && ("kind" in option2) ? mapOption(option2, casing, expressionState) : option2),
     table
   };
 };
@@ -5089,7 +5205,7 @@ var toEnumModel = (definition) => ({
   values: [...definition.values]
 });
 var enumModelsOfTable = (table) => {
-  const state = table[TypeId4];
+  const state = table[TypeId6];
   const fields = state.fields;
   return Object.values(fields).flatMap((column) => column.metadata.enum === undefined ? [] : [
     {