effect-qb 0.16.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,18 +170,86 @@ 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) => {
+  switch (action) {
+    case "noAction":
+      return "no action";
+    case "restrict":
+      return "restrict";
+    case "cascade":
+      return "cascade";
+    case "setNull":
+      return "set null";
+    case "setDefault":
+      return "set default";
+  }
+  throw new Error(referentialActionError);
+};
 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 = [];
@@ -213,6 +281,7 @@ var collectInlineOptions = (fields) => {
           return {
             tableName: bound.baseTableName,
             schemaName: bound.schemaName,
+            casing: bound.casing,
             columns: [bound.columnName]
           };
         },
@@ -245,89 +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") {
-          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}'`);
-            }
-          }
-          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}'`);
+          const keys = Array.isArray(option.keys) ? option.keys : [];
+          for (const key of keys) {
+            if (typeof key !== "object" || key === null || !("kind" in key)) {
+              continue;
             }
           }
-          if (option.columns === undefined && (option.keys === undefined || option.keys.length === 0)) {
-            throw new Error(`Index on table '${tableName}' requires at least one column or key`);
-          }
         }
         break;
       }
       case "check": {
         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) => {
@@ -344,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;
+  }
+  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("")}`;
     }
-    variants[key] = TableSchema.Field(config);
+    case "PascalCase":
+      return lowerWords(name).map(capitalize).join("");
+    case "kebab-case":
+      return lowerWords(name).join("-");
+    case "SCREAMING_SNAKE_CASE":
+      return lowerWords(name).join("_").toUpperCase();
   }
-  const struct = TableSchema.Struct(variants);
-  return {
-    select: TableSchema.extract(struct, "select"),
-    insert: TableSchema.extract(struct, "insert"),
-    update: TableSchema.extract(struct, "update")
-  };
 };
+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,
@@ -455,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 {
@@ -484,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,
@@ -501,40 +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) => ({
-  schemaName,
-  table: (name, fields, ...options2) => applyDeclaredOptions(makeTable(name, fields, [], name, "schema", schemaName, "explicit"), options2)
-});
+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,
@@ -568,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,
@@ -601,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)) {
@@ -632,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({
@@ -644,63 +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/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" });
@@ -732,7 +835,18 @@ var cloneContext = (context) => ({
   unknown: context.unknown
 });
 var freezeContext = (context) => context;
-var sourceNameOfKey = (key) => key.split(".", 1)[0] ?? key;
+var columnPredicateKey = (tableName, columnName) => JSON.stringify([tableName, columnName]);
+var columnPredicateKeyParts = (key) => {
+  const jsonSeparator = key.indexOf("#json:");
+  const columnKey = jsonSeparator === -1 ? key : key.slice(0, jsonSeparator);
+  try {
+    const parsed = JSON.parse(columnKey);
+    return Array.isArray(parsed) && parsed.length === 2 && typeof parsed[0] === "string" && typeof parsed[1] === "string" ? [parsed[0], parsed[1]] : undefined;
+  } catch {
+    return;
+  }
+};
+var sourceNameOfKey = (key) => columnPredicateKeyParts(key)?.[0] ?? key.split(".", 1)[0] ?? key;
 var addSourceName = (context, key) => {
   context.sourceNames.add(sourceNameOfKey(key));
 };
@@ -982,9 +1096,10 @@ var analyzeFormula = (formula) => freezeContext(analyzeStack(emptyContext(), [{
 var astOf = (value) => value[TypeId3];
 var columnKeyOfExpression = (value) => {
   const ast = astOf(value);
-  return ast.kind === "column" ? `${ast.tableName}.${ast.columnName}` : undefined;
+  return ast.kind === "column" ? columnPredicateKey(ast.tableName, ast.columnName) : undefined;
 };
 var sameDbType = (left, right) => left.dialect === right.dialect && left.kind === right.kind;
+var escapeJsonPathPredicateKeySegment = (value) => value.replaceAll("\\", "\\\\").replaceAll(".", "\\.");
 var jsonPathPredicateKeyOfExpression = (value) => {
   const ast = astOf(value);
   switch (ast.kind) {
@@ -1008,7 +1123,7 @@ var jsonPathPredicateKeyOfExpression = (value) => {
         return;
       }
       const baseKey = columnKeyOfExpression(jsonAst.base);
-      return baseKey === undefined ? undefined : `${baseKey}#json:${path.join(".")}`;
+      return baseKey === undefined ? undefined : `${baseKey}#json:${path.map(escapeJsonPathPredicateKeySegment).join(".")}`;
     }
     default:
       return;
@@ -1037,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";
@@ -1372,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,
@@ -1386,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;
@@ -1405,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]: {
@@ -1457,87 +1567,1002 @@ var descend = () => makeSegment({
   kind: "descend"
 });
 var path = (...segments) => ({
-  [TypeId7]: {
+  [TypeId8]: {
     segments
   },
   segments
 });
 
-// src/internal/runtime/driver-value-mapping.ts
-import * as Schema3 from "effect/Schema";
-
-// src/internal/runtime/normalize.ts
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var pad = (value, width = 2) => value.toString().padStart(width, "0");
-var formatLocalDate = (value) => `${value.getUTCFullYear()}-${pad(value.getUTCMonth() + 1)}-${pad(value.getUTCDate())}`;
-var formatLocalTime = (value) => {
-  const milliseconds = value.getUTCMilliseconds();
-  const base = `${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
-  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
-};
-var formatLocalDateTime = (value) => {
-  const milliseconds = value.getUTCMilliseconds();
-  const base = `${formatLocalDate(value)}T${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
-  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
-};
-var runtimeTagOfBaseDbType = (dbType) => {
-  return dbType.runtime;
-};
-var expectString = (value, label) => {
-  if (typeof value === "string") {
-    return value;
-  }
-  throw new Error(`Expected ${label} as string`);
-};
-var normalizeNumber = (value) => {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) {
-      return parsed;
-    }
-  }
-  if (typeof value === "bigint" && Number.isSafeInteger(Number(value))) {
-    return Number(value);
-  }
-  throw new Error("Expected a finite numeric value");
-};
-var normalizeBoolean = (value) => {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "number") {
-    if (value === 1) {
-      return true;
-    }
-    if (value === 0) {
-      return false;
+// src/internal/dsl-plan-runtime.ts
+var renderSelectLockMode = (mode) => mode === "update" ? "for update" : "for share";
+var renderMysqlMutationLockMode = (mode, _statement) => {
+  if (mode === "lowPriority") {
+    return " low_priority";
+  }
+  return mode === "ignore" ? " ignore" : " quick";
+};
+var makeDslPlanRuntime = (ctx) => {
+  const sourceRequiredList = (source) => typeof source === "object" && source !== null && ("required" in source) ? ctx.currentRequiredList(source.required) : [];
+  const buildSetOperation = (kind, all, left, right) => {
+    const leftState = left[TypeId];
+    const leftAst = ctx.getAst(left);
+    const basePlan = leftAst.kind === "set" ? leftAst.setBase ?? left : left;
+    const leftOperations = leftAst.kind === "set" ? [...leftAst.setOperations ?? []] : [];
+    return ctx.makePlan({
+      selection: leftState.selection,
+      required: undefined,
+      available: {},
+      dialect: leftState.dialect ?? right[TypeId].dialect
+    }, {
+      kind: "set",
+      select: leftState.selection,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: [],
+      setBase: basePlan,
+      setOperations: [
+        ...leftOperations,
+        {
+          kind,
+          all,
+          query: right
+        }
+      ]
+    }, undefined, undefined, "set");
+  };
+  const where = (predicate) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const predicateExpression = ctx.toDialectExpression(predicate);
+    const predicateRequired = ctx.extractRequiredFromDialectInputRuntime(predicate);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...predicateRequired].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? predicateExpression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      where: [...currentAst.where, {
+        kind: "where",
+        predicate: predicateExpression
+      }]
+    }, ctx.assumeFormulaTrue(currentQuery.assumptions, ctx.formulaOfExpressionRuntime(predicateExpression)), currentQuery.capabilities, currentQuery.statement);
+  };
+  const from = (source) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    if (currentQuery.statement === "insert") {
+      return ctx.attachInsertSource(plan, source);
     }
-  }
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "true" || normalized === "t" || normalized === "1") {
-      return true;
+    const sourceLike = source;
+    const { sourceName, sourceBaseName } = ctx.sourceDetails(sourceLike);
+    const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(sourceLike);
+    const sourceRequired = sourceRequiredList(sourceLike);
+    if (currentQuery.statement === "select") {
+      const nextAvailable = {
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName,
+          _presentFormula: ctx.trueFormula(),
+          _presenceWitnesses: presenceWitnesses
+        }
+      };
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index3, values) => !(name in nextAvailable) && values.indexOf(name) === index3),
+        available: nextAvailable,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        from: {
+          kind: "from",
+          tableName: sourceName,
+          baseTableName: sourceBaseName,
+          source: sourceLike
+        }
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
     }
-    if (normalized === "false" || normalized === "f" || normalized === "0") {
-      return false;
+    if (currentQuery.statement === "update") {
+      const nextAvailable = {
+        ...current.available,
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName,
+          _presentFormula: ctx.trueFormula(),
+          _presenceWitnesses: presenceWitnesses
+        }
+      };
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index3, values) => !(name in nextAvailable) && values.indexOf(name) === index3),
+        available: nextAvailable,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        fromSources: [
+          ...currentAst.fromSources ?? [],
+          {
+            kind: "from",
+            tableName: sourceName,
+            baseTableName: sourceBaseName,
+            source: sourceLike
+          }
+        ]
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
     }
-  }
-  throw new Error("Expected a boolean-like value");
+    return plan;
+  };
+  const having = (predicate) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const predicateExpression = ctx.toDialectExpression(predicate);
+    const predicateRequired = ctx.extractRequiredFromDialectInputRuntime(predicate);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...predicateRequired].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? predicateExpression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      having: [...currentAst.having, {
+        kind: "having",
+        predicate: predicateExpression
+      }]
+    }, ctx.assumeFormulaTrue(currentQuery.assumptions, ctx.formulaOfExpressionRuntime(predicateExpression)), currentQuery.capabilities, currentQuery.statement);
+  };
+  const crossJoin = (table) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const { sourceName, sourceBaseName } = ctx.sourceDetails(table);
+    const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table);
+    const sourceRequired = sourceRequiredList(table);
+    const nextAvailable = {
+      ...current.available,
+      [sourceName]: {
+        name: sourceName,
+        mode: "required",
+        baseName: sourceBaseName,
+        _presentFormula: ctx.trueFormula(),
+        _presenceWitnesses: presenceWitnesses
+      }
+    };
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...sourceRequired].filter((name, index3, values) => !(name in nextAvailable) && values.indexOf(name) === index3),
+      available: nextAvailable,
+      dialect: current.dialect ?? table[TypeId]?.dialect ?? table.dialect
+    }, {
+      ...currentAst,
+      joins: [...currentAst.joins, {
+        kind: "cross",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: table
+      }]
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const join = (kind, table, on) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const onExpression = ctx.toDialectExpression(on);
+    const onFormula = ctx.formulaOfExpressionRuntime(onExpression);
+    const { sourceName, sourceBaseName } = ctx.sourceDetails(table);
+    const presenceWitnesses = ctx.presenceWitnessesOfSourceLike(table);
+    const sourceRequired = sourceRequiredList(table);
+    const baseAvailable = kind === "right" || kind === "full" ? Object.fromEntries(Object.entries(current.available).map(([name, source]) => [name, {
+      name: source.name,
+      mode: "optional",
+      baseName: source.baseName,
+      _presentFormula: source._presentFormula,
+      _presenceWitnesses: source._presenceWitnesses
+    }])) : current.available;
+    const nextAvailable = {
+      ...baseAvailable,
+      [sourceName]: {
+        name: sourceName,
+        mode: kind === "left" || kind === "full" ? "optional" : "required",
+        baseName: sourceBaseName,
+        _presentFormula: kind === "inner" || kind === "left" ? onFormula : ctx.trueFormula(),
+        _presenceWitnesses: presenceWitnesses
+      }
+    };
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...sourceRequired, ...ctx.extractRequiredFromDialectInputRuntime(on)].filter((name, index3, values) => !(name in nextAvailable) && values.indexOf(name) === index3),
+      available: nextAvailable,
+      dialect: current.dialect ?? table.dialect ?? onExpression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      joins: [...currentAst.joins, {
+        kind,
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: table,
+        on: onExpression
+      }]
+    }, kind === "inner" ? ctx.assumeFormulaTrue(currentQuery.assumptions, onFormula) : currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const orderBy = (value, direction = "asc") => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const expression = ctx.toDialectExpression(value);
+    const required = ctx.extractRequiredFromDialectInputRuntime(value);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? expression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      orderBy: [...currentAst.orderBy, {
+        kind: "orderBy",
+        value: expression,
+        direction
+      }]
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const lock = (mode, options2 = {}) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: current.required,
+      available: current.available,
+      dialect: current.dialect
+    }, {
+      ...currentAst,
+      lock: {
+        kind: "lock",
+        mode,
+        nowait: options2.nowait ?? false,
+        skipLocked: options2.skipLocked ?? false
+      }
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const distinct = () => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: current.required,
+      available: current.available,
+      dialect: current.dialect
+    }, {
+      ...currentAst,
+      distinct: true
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const limit = (value) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const expression = ctx.toDialectNumericExpression(value);
+    const required = ctx.extractRequiredFromDialectNumericInputRuntime(value);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? expression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      limit: expression
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  const offset = (value) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const expression = ctx.toDialectNumericExpression(value);
+    const required = ctx.extractRequiredFromDialectNumericInputRuntime(value);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: [...ctx.currentRequiredList(current.required), ...required].filter((name, index3, values) => !(name in current.available) && values.indexOf(name) === index3),
+      available: current.available,
+      dialect: current.dialect ?? expression[TypeId2].dialect
+    }, {
+      ...currentAst,
+      offset: expression
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement);
+  };
+  return {
+    buildSetOperation,
+    where,
+    from,
+    having,
+    crossJoin,
+    join,
+    orderBy,
+    lock,
+    distinct,
+    limit,
+    offset
+  };
 };
-var normalizeBigIntString = (value) => {
-  if (typeof value === "bigint") {
-    return value.toString();
+
+// src/internal/dsl-transaction-ddl-runtime.ts
+var renderTransactionIsolationLevel = (isolationLevel) => {
+  if (isolationLevel === undefined) {
+    return "";
   }
-  if (typeof value === "number" && Number.isSafeInteger(value)) {
-    return BigInt(value).toString();
+  return `isolation level ${isolationLevel}`;
+};
+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 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 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 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 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 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) => {
+    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));
+    const insertState = values === undefined ? "missing" : "ready";
+    return ctx.makePlan({
+      selection: {},
+      required: required.filter((name, index3, list) => name !== sourceName && list.indexOf(name) === index3),
+      available: {
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName
+        }
+      },
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "insert",
+      select: {},
+      into: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      values: assignments,
+      conflict: undefined,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "insert", target, insertState);
+  };
+  const attachInsertSource = (plan, source) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const target = currentQuery.target;
+    const sourceName = currentAst.into.tableName;
+    if (typeof source === "object" && source !== null && "kind" in source && source.kind === "values") {
+      const normalized = ctx.buildInsertValuesRows(target, source.rows);
+      return ctx.makePlan({
+        selection: current.selection,
+        required: normalized.required.filter((name) => name !== sourceName),
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        values: [],
+        insertSource: {
+          kind: "values",
+          columns: normalized.columns,
+          rows: normalized.rows
+        }
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready");
+    }
+    if (typeof source === "object" && source !== null && "kind" in source && source.kind === "unnest") {
+      const normalized = ctx.normalizeInsertUnnestValues(target, source.values);
+      return ctx.makePlan({
+        selection: current.selection,
+        required: [],
+        available: current.available,
+        dialect: current.dialect
+      }, {
+        ...currentAst,
+        values: [],
+        insertSource: {
+          kind: "unnest",
+          columns: normalized.columns,
+          values: normalized.values
+        }
+      }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready");
+    }
+    const sourcePlan = source;
+    const selection = sourcePlan[TypeId].selection;
+    const columns = ctx.normalizeInsertSelectColumns(selection);
+    return ctx.makePlan({
+      selection: current.selection,
+      required: ctx.currentRequiredList(sourcePlan[TypeId].required),
+      available: current.available,
+      dialect: current.dialect
+    }, {
+      ...currentAst,
+      values: [],
+      insertSource: {
+        kind: "query",
+        columns,
+        query: sourcePlan
+      }
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, "ready");
+  };
+  const onConflict = (target, options2 = {}) => (plan) => {
+    const current = plan[TypeId];
+    const currentAst = ctx.getAst(plan);
+    const currentQuery = ctx.getQueryState(plan);
+    const insertTarget = currentAst.into.source;
+    const conflictTarget = expectConflictClause({
+      kind: "conflict",
+      action: "doNothing",
+      target: ctx.buildConflictTarget(insertTarget, target)
+    }).target;
+    const updateAssignments = options2.update ? ctx.buildMutationAssignments(insertTarget, options2.update) : [];
+    const updateWhere = options2.where === undefined ? undefined : ctx.toDialectExpression(options2.where);
+    const targetWhere = conflictTarget.kind === "columns" ? conflictTarget.where : undefined;
+    const required = [
+      ...ctx.currentRequiredList(current.required),
+      ...updateAssignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)),
+      ...updateWhere ? Object.keys(updateWhere[TypeId2].dependencies) : [],
+      ...targetWhere ? Object.keys(targetWhere[TypeId2].dependencies) : []
+    ].filter((name, index3, list) => !(name in current.available) && list.indexOf(name) === index3);
+    return ctx.makePlan({
+      selection: current.selection,
+      required,
+      available: current.available,
+      dialect: current.dialect
+    }, {
+      ...currentAst,
+      conflict: {
+        kind: "conflict",
+        target: conflictTarget,
+        action: updateAssignments.length === 0 ? "doNothing" : "doUpdate",
+        values: updateAssignments.length === 0 ? undefined : updateAssignments,
+        where: updateWhere
+      }
+    }, currentQuery.assumptions, currentQuery.capabilities, currentQuery.statement, currentQuery.target, currentQuery.insertSource);
+  };
+  const update = (target, values) => {
+    const targets = ctx.mutationTargetClauses(target);
+    const primaryTarget = targets[0];
+    const assignments = ctx.buildMutationAssignments(target, values);
+    const targetNames = new Set(targets.map((entry) => entry.tableName));
+    const required = assignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)).filter((name, index3, list) => !targetNames.has(name) && list.indexOf(name) === index3);
+    return ctx.makePlan({
+      selection: {},
+      required,
+      available: ctx.mutationAvailableSources(target),
+      dialect: primaryTarget.source[TypeId].dialect
+    }, {
+      kind: "update",
+      select: {},
+      target: primaryTarget,
+      targets,
+      set: assignments,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "update");
+  };
+  const upsert = (target, values, conflictColumns, updateValues) => {
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    const assignments = ctx.buildMutationAssignments(target, values);
+    const updateAssignments = updateValues ? ctx.buildMutationAssignments(target, updateValues) : [];
+    const required = [
+      ...assignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)),
+      ...updateAssignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies))
+    ];
+    return ctx.makePlan({
+      selection: {},
+      required: required.filter((name, index3, list) => name !== sourceName && list.indexOf(name) === index3),
+      available: {
+        [sourceName]: {
+          name: sourceName,
+          mode: "required",
+          baseName: sourceBaseName
+        }
+      },
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "insert",
+      select: {},
+      into: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      values: assignments,
+      conflict: {
+        kind: "conflict",
+        target: {
+          kind: "columns",
+          columns: ctx.normalizeConflictColumns(target, conflictColumns)
+        },
+        action: updateAssignments.length > 0 ? "doUpdate" : "doNothing",
+        values: updateAssignments.length > 0 ? updateAssignments : undefined
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "insert", target, "ready");
+  };
+  const delete_ = (target) => {
+    const targets = ctx.mutationTargetClauses(target);
+    const primaryTarget = targets[0];
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: ctx.mutationAvailableSources(target),
+      dialect: primaryTarget.source[TypeId].dialect
+    }, {
+      kind: "delete",
+      select: {},
+      target: primaryTarget,
+      targets,
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "delete");
+  };
+  const truncate = (target, options2 = {}) => {
+    const restartIdentity = normalizeStatementFlag(options2.restartIdentity);
+    const cascade = normalizeStatementFlag(options2.cascade);
+    const { sourceName, sourceBaseName } = ctx.targetSourceDetails(target);
+    return ctx.makePlan({
+      selection: {},
+      required: [],
+      available: {},
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "truncate",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: sourceName,
+        baseTableName: sourceBaseName,
+        source: target
+      },
+      truncate: {
+        kind: "truncate",
+        restartIdentity,
+        cascade
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "truncate");
+  };
+  const merge2 = (target, source, on, options2 = {}) => {
+    const { sourceName: targetName, sourceBaseName: targetBaseName } = ctx.targetSourceDetails(target);
+    const { sourceName: usingName, sourceBaseName: usingBaseName } = ctx.sourceDetails(source);
+    const onExpression = ctx.toDialectExpression(on);
+    const matched = options2.whenMatched;
+    const notMatched = options2.whenNotMatched;
+    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;
+    const notMatchedAssignments = notMatched ? ctx.buildMutationAssignments(target, notMatched.values) : [];
+    const required = [
+      ...Object.keys(onExpression[TypeId2].dependencies),
+      ...matchedAssignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)),
+      ...notMatchedAssignments.flatMap((entry) => Object.keys(entry.value[TypeId2].dependencies)),
+      ...matchedPredicate ? Object.keys(matchedPredicate[TypeId2].dependencies) : [],
+      ...notMatchedPredicate ? Object.keys(notMatchedPredicate[TypeId2].dependencies) : []
+    ].filter((name, index3, values) => name !== targetName && name !== usingName && values.indexOf(name) === index3);
+    return ctx.makePlan({
+      selection: {},
+      required,
+      available: {
+        [targetName]: {
+          name: targetName,
+          mode: "required",
+          baseName: targetBaseName
+        },
+        [usingName]: {
+          name: usingName,
+          mode: "required",
+          baseName: usingBaseName
+        }
+      },
+      dialect: target[TypeId].dialect
+    }, {
+      kind: "merge",
+      select: {},
+      target: {
+        kind: "from",
+        tableName: targetName,
+        baseTableName: targetBaseName,
+        source: target
+      },
+      using: {
+        kind: "from",
+        tableName: usingName,
+        baseTableName: usingBaseName,
+        source
+      },
+      merge: {
+        kind: "merge",
+        on: onExpression,
+        whenMatched: matched ? "delete" in matched && matched.delete ? {
+          kind: "delete",
+          predicate: matchedPredicate
+        } : {
+          kind: "update",
+          values: matchedAssignments,
+          predicate: matchedPredicate
+        } : undefined,
+        whenNotMatched: notMatched ? {
+          kind: "insert",
+          values: notMatchedAssignments,
+          predicate: notMatchedPredicate
+        } : undefined
+      },
+      where: [],
+      having: [],
+      joins: [],
+      groupBy: [],
+      orderBy: []
+    }, undefined, "write", "merge");
+  };
+  return {
+    insert,
+    attachInsertSource,
+    onConflict,
+    update,
+    upsert,
+    delete_,
+    truncate,
+    merge: merge2
+  };
+};
+
+// src/internal/runtime/driver-value-mapping.ts
+import * as Schema4 from "effect/Schema";
+
+// src/internal/runtime/value.ts
+import * as Schema3 from "effect/Schema";
+var brandString = (pattern2, brand4) => Schema3.String.pipe(Schema3.pattern(pattern2), Schema3.brand(brand4));
+var localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
+var isValidLocalDateString = (value) => {
+  const match = localDatePattern.exec(value);
+  if (match === null) {
+    return false;
+  }
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const parsed = new Date(Date.UTC(year, month - 1, day));
+  parsed.setUTCFullYear(year);
+  return parsed.getUTCFullYear() === year && parsed.getUTCMonth() === month - 1 && parsed.getUTCDate() === day;
+};
+var localTimePattern = /^(\d{2}):(\d{2}):(\d{2})(?:\.\d+)?$/;
+var isValidLocalTimeString = (value) => {
+  const match = localTimePattern.exec(value);
+  if (match === null) {
+    return false;
   }
-  if (typeof value === "string" && /^-?\d+$/.test(value.trim())) {
-    return BigInt(value.trim()).toString();
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  const second = Number(match[3]);
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59 && second >= 0 && second <= 59;
+};
+var offsetPattern = /^(?:Z|[+-](\d{2}):(\d{2}))$/;
+var isValidOffset = (value) => {
+  const match = offsetPattern.exec(value);
+  if (match === null) {
+    return false;
+  }
+  if (value === "Z") {
+    return true;
+  }
+  const hour = Number(match[1]);
+  const minute = Number(match[2]);
+  return hour >= 0 && hour <= 23 && minute >= 0 && minute <= 59;
+};
+var offsetTimePattern = /^(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/;
+var isValidOffsetTimeString = (value) => {
+  const match = offsetTimePattern.exec(value);
+  return match !== null && isValidLocalTimeString(match[1]) && isValidOffset(match[2]);
+};
+var localDateTimePattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)$/;
+var isValidLocalDateTimeString = (value) => {
+  const match = localDateTimePattern.exec(value);
+  return match !== null && isValidLocalDateString(match[1]) && isValidLocalTimeString(match[2]);
+};
+var instantPattern = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2}:\d{2}(?:\.\d+)?)(Z|[+-]\d{2}:\d{2})$/;
+var isValidInstantString = (value) => {
+  const match = instantPattern.exec(value);
+  return match !== null && isValidLocalDateString(match[1]) && isValidLocalTimeString(match[2]) && isValidOffset(match[3]);
+};
+var LocalDateStringSchema = Schema3.String.pipe(Schema3.pattern(localDatePattern), Schema3.filter(isValidLocalDateString), Schema3.brand("LocalDateString"));
+var LocalTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localTimePattern), Schema3.filter(isValidLocalTimeString), Schema3.brand("LocalTimeString"));
+var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.pattern(offsetTimePattern), Schema3.filter(isValidOffsetTimeString), Schema3.brand("OffsetTimeString"));
+var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.pattern(localDateTimePattern), Schema3.filter(isValidLocalDateTimeString), Schema3.brand("LocalDateTimeString"));
+var InstantStringSchema = Schema3.String.pipe(Schema3.pattern(instantPattern), Schema3.filter(isValidInstantString), Schema3.brand("InstantString"));
+var YearStringSchema = brandString(/^\d{4}$/, "YearString");
+var canonicalizeBigIntString = (input) => {
+  const trimmed = input.trim();
+  if (!/^-?\d+$/.test(trimmed)) {
+    throw new Error("Expected an integer-like bigint value");
+  }
+  return BigInt(trimmed).toString();
+};
+var isCanonicalBigIntString = (value) => {
+  try {
+    return canonicalizeBigIntString(value) === value;
+  } catch {
+    return false;
   }
-  throw new Error("Expected an integer-like bigint value");
 };
 var canonicalizeDecimalString = (input) => {
   const trimmed = input.trim();
@@ -1549,10 +2574,116 @@ var canonicalizeDecimalString = (input) => {
   const integer = match[2].replace(/^0+(?=\d)/, "") || "0";
   const fraction = (match[3] ?? "").replace(/0+$/, "");
   if (fraction.length === 0) {
+    if (integer === "0") {
+      return "0";
+    }
     return `${sign}${integer}`;
   }
   return `${sign}${integer}.${fraction}`;
 };
+var isCanonicalDecimalString = (value) => {
+  try {
+    return canonicalizeDecimalString(value) === value;
+  } catch {
+    return false;
+  }
+};
+var BigIntStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalBigIntString), Schema3.brand("BigIntString"));
+var DecimalStringSchema = Schema3.String.pipe(Schema3.filter(isCanonicalDecimalString), Schema3.brand("DecimalString"));
+var JsonValueSchema = Schema3.suspend(() => Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null, Schema3.Array(JsonValueSchema), Schema3.Record({
+  key: Schema3.String,
+  value: JsonValueSchema
+})));
+var JsonPrimitiveSchema = Schema3.Union(Schema3.String, Schema3.Number.pipe(Schema3.finite()), Schema3.Boolean, Schema3.Null);
+
+// src/internal/runtime/normalize.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isPlainRecord = (value) => {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(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();
+  const base = `${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
+  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
+};
+var formatLocalDateTime = (value) => {
+  const milliseconds = value.getUTCMilliseconds();
+  const base = `${formatLocalDate(value)}T${pad(value.getUTCHours())}:${pad(value.getUTCMinutes())}:${pad(value.getUTCSeconds())}`;
+  return milliseconds === 0 ? base : `${base}.${pad(milliseconds, 3)}`;
+};
+var runtimeTagOfBaseDbType = (dbType) => {
+  return dbType.runtime;
+};
+var expectString = (value, label) => {
+  if (typeof value === "string") {
+    return value;
+  }
+  throw new Error(`Expected ${label} as string`);
+};
+var finiteNumberStringPattern = /^[+-]?(?:(?:\d+\.?\d*)|(?:\.\d+))(?:[eE][+-]?\d+)?$/;
+var normalizeNumber = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    const parsed = finiteNumberStringPattern.test(trimmed) ? Number(trimmed) : Number.NaN;
+    if (Number.isFinite(parsed)) {
+      return parsed;
+    }
+  }
+  if (typeof value === "bigint" && Number.isSafeInteger(Number(value))) {
+    return Number(value);
+  }
+  throw new Error("Expected a finite numeric value");
+};
+var normalizeBoolean = (value) => {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+  }
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "t" || normalized === "1") {
+      return true;
+    }
+    if (normalized === "false" || normalized === "f" || normalized === "0") {
+      return false;
+    }
+  }
+  throw new Error("Expected a boolean-like value");
+};
+var normalizeBigIntString = (value) => {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value)) {
+    return BigInt(value).toString();
+  }
+  if (typeof value === "string") {
+    return canonicalizeBigIntString(value);
+  }
+  throw new Error("Expected an integer-like bigint value");
+};
 var normalizeDecimalString = (value) => {
   if (typeof value === "string") {
     return canonicalizeDecimalString(value);
@@ -1568,48 +2699,53 @@ 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 (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+  if (isValidLocalDateString(raw)) {
     return raw;
   }
-  const parsed = new Date(raw);
-  if (!Number.isNaN(parsed.getTime())) {
-    return formatLocalDate(parsed);
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z");
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant);
+    if (!Number.isNaN(parsed.getTime())) {
+      return formatLocalDate(parsed);
+    }
   }
   throw new Error("Expected a local-date value");
 };
 var normalizeLocalTime = (value) => {
   if (value instanceof Date) {
-    return formatLocalTime(value);
+    return formatLocalTime(validDate(value));
   }
   const raw = expectString(value, "local time").trim();
-  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
+  if (isValidLocalTimeString(raw)) {
     return raw;
   }
   throw new Error("Expected a local-time 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 (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
+  if (isValidOffsetTimeString(raw)) {
     return raw;
   }
   throw new Error("Expected an offset-time value");
 };
 var normalizeLocalDateTime = (value) => {
   if (value instanceof Date) {
-    return formatLocalDateTime(value);
+    return formatLocalDateTime(validDate(value));
   }
   const raw = expectString(value, "local datetime").trim();
-  if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
-    return raw.replace(" ", "T");
+  const canonicalLocalDateTime = raw.replace(" ", "T");
+  if (isValidLocalDateTimeString(canonicalLocalDateTime)) {
+    return canonicalLocalDateTime;
   }
-  if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
-    const parsed = new Date(raw);
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z");
+  if (isValidInstantString(canonicalInstant)) {
+    const parsed = new Date(canonicalInstant);
     if (!Number.isNaN(parsed.getTime())) {
       return formatLocalDateTime(parsed);
     }
@@ -1618,13 +2754,17 @@ 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)) {
     throw new Error("Instant values require a timezone offset");
   }
-  const parsed = new Date(raw);
+  const canonicalInstant = raw.replace(" ", "T").replace(/z$/, "Z");
+  if (!isValidInstantString(canonicalInstant)) {
+    throw new Error("Expected an ISO instant value");
+  }
+  const parsed = new Date(canonicalInstant);
   if (Number.isNaN(parsed.getTime())) {
     throw new Error("Expected an ISO instant value");
   }
@@ -1656,25 +2796,33 @@ var isJsonValue = (value) => {
   }
   switch (typeof value) {
     case "string":
-    case "number":
     case "boolean":
       return true;
+    case "number":
+      return Number.isFinite(value);
     case "object":
       if (Array.isArray(value)) {
         return value.every(isJsonValue);
       }
-      return isRecord(value) && Object.values(value).every(isJsonValue);
+      return isPlainRecord(value) && Object.values(value).every(isJsonValue);
     default:
       return false;
   }
 };
 var normalizeJson = (value) => {
   if (typeof value === "string") {
-    const parsed = JSON.parse(value);
-    if (isJsonValue(parsed)) {
-      return parsed;
+    try {
+      const parsed = JSON.parse(value);
+      if (isJsonValue(parsed)) {
+        return parsed;
+      }
+      throw new Error("Parsed JSON value is not a valid JSON runtime");
+    } catch (error) {
+      if (error instanceof SyntaxError) {
+        return value;
+      }
+      throw error;
     }
-    throw new Error("Parsed JSON value is not a valid JSON runtime");
   }
   if (isJsonValue(value)) {
     return value;
@@ -1809,22 +2957,61 @@ var findMapping = (context, key2) => {
   }
   return;
 };
-var encodeWithSchema = (schema2, value) => {
-  if (schema2 === undefined) {
+var isJsonDbType = (dbType) => {
+  if (dbType === undefined) {
+    return false;
+  }
+  if ("base" in dbType) {
+    return isJsonDbType(dbType.base);
+  }
+  if (!("variant" in dbType)) {
+    return false;
+  }
+  const variant = dbType.variant;
+  return variant === "json" || variant === "jsonb";
+};
+var schemaAccepts = (schema, value) => schema !== undefined && Schema4.is(schema)(value);
+var encodeWithSchema = (schema, value) => {
+  if (schema === undefined) {
     return { value, encoded: false };
   }
-  if (!Schema3.is(schema2)(value)) {
+  if (!Schema4.is(schema)(value)) {
     return { value, encoded: false };
   }
   return {
-    value: Schema3.encodeUnknownSync(schema2)(value),
+    value: Schema4.encodeUnknownSync(schema)(value),
     encoded: true
   };
 };
+var normalizeJsonDriverString = (value, context) => {
+  if (!isJsonDbType(context.dbType) || context.runtimeSchema === undefined) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (value.trimStart().startsWith('"') && schemaAccepts(context.runtimeSchema, parsed)) {
+      return parsed;
+    }
+    if (schemaAccepts(context.runtimeSchema, value) && !schemaAccepts(context.runtimeSchema, parsed)) {
+      return value;
+    }
+  } catch (error) {
+    if (error instanceof SyntaxError && schemaAccepts(context.runtimeSchema, value)) {
+      return value;
+    }
+    if (!(error instanceof SyntaxError)) {
+      throw error;
+    }
+  }
+  return;
+};
 var toDriverValue = (value, context) => {
   if (value === null) {
     return null;
   }
+  if (value instanceof Date && Number.isNaN(value.getTime())) {
+    throw new Error("Expected a valid Date value");
+  }
   const dbType = context.dbType;
   const encoded = encodeWithSchema(context.runtimeSchema, value);
   let current = encoded.value;
@@ -1832,6 +3019,9 @@ var toDriverValue = (value, context) => {
   if (custom !== undefined && dbType !== undefined) {
     return custom(current, dbType);
   }
+  if (encoded.encoded && typeof current === "string" && isJsonDbType(dbType)) {
+    return current;
+  }
   return dbType === undefined || !encoded.encoded ? current : normalizeDbValue(dbType, current);
 };
 var fromDriverValue = (value, context) => {
@@ -1843,6 +3033,12 @@ var fromDriverValue = (value, context) => {
   if (custom !== undefined && dbType !== undefined) {
     return custom(value, dbType);
   }
+  if (typeof value === "string") {
+    const normalizedJsonString = normalizeJsonDriverString(value, context);
+    if (normalizedJsonString !== undefined) {
+      return normalizedJsonString;
+    }
+  }
   return dbType === undefined ? value : normalizeDbValue(dbType, value);
 };
 var textCast = (sql) => `(${sql})::text`;
@@ -1879,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]);
@@ -1930,9 +3126,23 @@ var validateProjections = (projections) => {
 };
 
 // src/internal/grouping-key.ts
+var subqueryPlanIds = new WeakMap;
+var nextSubqueryPlanId = 0;
+var subqueryPlanGroupingKey = (plan) => {
+  if (plan === null || typeof plan !== "object") {
+    return "unknown";
+  }
+  const existing = subqueryPlanIds.get(plan);
+  if (existing !== undefined) {
+    return existing;
+  }
+  const next = `${nextSubqueryPlanId++}`;
+  subqueryPlanIds.set(plan, next);
+  return next;
+};
 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";
@@ -1948,15 +3158,99 @@ var literalGroupingKey = (value) => {
       return `literal:${JSON.stringify(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) {
+      case "key":
+        return `key:${escapeGroupingText(segment.key)}`;
+      case "index":
+        return `index:${segment.index}`;
+      case "wildcard":
+        return "wildcard";
+      case "slice": {
+        const slice2 = segment;
+        return `slice:${slice2.start ?? ""}:${slice2.end ?? ""}`;
+      }
+      case "descend":
+        return "descend";
+    }
+  }
+  if (typeof segment === "string") {
+    return `key:${escapeGroupingText(segment)}`;
+  }
+  if (typeof segment === "number") {
+    return `index:${segment}`;
+  }
+  return "unknown";
+};
+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)}`;
+  }
+  if (typeof value === "string") {
+    return `jsonpath:${escapeGroupingText(value)}`;
+  }
+  if (isExpression2(value)) {
+    return `jsonpath:${groupingKeyOfExpression(value)}`;
+  }
+  return "jsonpath:unknown";
+};
+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) {
     case "column":
-      return `column:${ast.tableName}.${ast.columnName}`;
+      return `column:${columnPredicateKey(ast.tableName, ast.columnName)}`;
     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(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`;
+    case "function":
+      return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`;
     case "isNull":
     case "isNotNull":
     case "not":
@@ -1965,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":
@@ -1974,9 +3268,16 @@ var groupingKeyOfExpression = (expression) => {
     case "gte":
     case "like":
     case "ilike":
+    case "regexMatch":
+    case "regexIMatch":
+    case "regexNotMatch":
+    case "regexNotIMatch":
     case "isDistinctFrom":
     case "isNotDistinctFrom":
-      return `${ast.kind}(${groupingKeyOfExpression(ast.left)},${groupingKeyOfExpression(ast.right)})`;
+    case "contains":
+    case "containedBy":
+    case "overlaps":
+      return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`;
     case "and":
     case "or":
     case "coalesce":
@@ -1984,11 +3285,59 @@ 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(${requiredExpressionGroupingKey("inSubquery", ast.left)},${subqueryPlanGroupingKey(ast.plan)})`;
+    case "comparisonAny":
+    case "comparisonAll":
+      return `${ast.kind}(${ast.operator},${requiredExpressionGroupingKey(quantifiedComparisonGroupingName(ast.kind), ast.left)},${subqueryPlanGroupingKey(ast.plan)})`;
+    case "jsonGet":
+    case "jsonPath":
+    case "jsonAccess":
+    case "jsonTraverse":
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonPathGroupingKey(ast.segments)})`;
+    case "jsonHasKey":
+    case "jsonKeyExists":
+    case "jsonHasAnyKeys":
+    case "jsonHasAllKeys":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonKeysGroupingKey(ast.keys)})`;
+    case "jsonConcat":
+    case "jsonMerge":
+      return `json(${ast.kind},${expressionGroupingKey(ast.left)},${expressionGroupingKey(ast.right)},)`;
+    case "jsonDelete":
+    case "jsonDeletePath":
+    case "jsonRemove":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(undefined)},${jsonPathGroupingKey(ast.segments)})`;
+    case "jsonSet":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(ast.newValue)},${jsonPathGroupingKey(ast.segments)})`;
+    case "jsonInsert":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${expressionGroupingKey(ast.insert)},${jsonPathGroupingKey(ast.segments)})`;
+    case "jsonPathExists":
+    case "jsonPathMatch":
+      return `json(${ast.kind},${expressionGroupingKey(ast.base)},${jsonOpaquePathGroupingKey(ast.query)})`;
+    case "jsonBuildObject":
+      return `json(${ast.kind},${jsonBuildObjectGroupingKey(ast.entries)})`;
+    case "jsonBuildArray":
+      return `json(${ast.kind},${jsonBuildArrayGroupingKey(ast.values)})`;
+    case "jsonToJson":
+    case "jsonToJsonb":
+    case "jsonTypeOf":
+    case "jsonLength":
+    case "jsonKeys":
+    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) => {
@@ -2003,51 +3352,20 @@ var dedupeGroupedExpressions = (values) => {
   });
 };
 
-// src/internal/aggregation-validation.ts
-var isExpression2 = (value) => typeof value === "object" && value !== null && (TypeId2 in value);
-var selectionHasAggregate = (selection) => {
-  if (isExpression2(selection)) {
-    return selection[TypeId2].kind === "aggregate";
-  }
-  return Object.values(selection).some((value) => selectionHasAggregate(value));
-};
-var isGroupedSelectionValid = (selection, groupedExpressions) => {
-  if (isExpression2(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":
@@ -2062,21 +3380,145 @@ 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 renderDdlExpression = (expression, state, dialect) => isSchemaExpression(expression) ? render(expression) : renderExpression(expression, state, dialect);
-var renderColumnDefinition = (dialect, state, columnName, column) => {
+var renderPostgresDdlString = (value) => `'${value.replaceAll("'", "''")}'`;
+var renderPostgresDdlBytes = (value) => `decode('${Array.from(value, (byte) => byte.toString(16).padStart(2, "0")).join("")}', 'hex')`;
+var renderPostgresDdlLiteral = (value, state, context = {}) => {
+  const driverValue = toDriverValue(value, {
+    dialect: "postgres",
+    valueMappings: state.valueMappings,
+    ...context
+  });
+  if (driverValue === null) {
+    return "null";
+  }
+  switch (typeof driverValue) {
+    case "boolean":
+      return driverValue ? "true" : "false";
+    case "number":
+      if (!Number.isFinite(driverValue)) {
+        throw new Error("Expected a finite numeric value");
+      }
+      return String(driverValue);
+    case "bigint":
+      return driverValue.toString();
+    case "string":
+      return renderPostgresDdlString(driverValue);
+    case "object":
+      if (driverValue instanceof Uint8Array) {
+        return renderPostgresDdlBytes(driverValue);
+      }
+      break;
+  }
+  throw new Error("Unsupported postgres DDL literal value");
+};
+var renderDdlExpression = (expression, state, dialect) => {
+  if (isSchemaExpression(expression)) {
+    return render(expression);
+  }
+  return renderExpression2(expression, state, {
+    ...dialect,
+    renderLiteral: renderPostgresDdlLiteral
+  });
+};
+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");
@@ -2084,39 +3526,135 @@ 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 ? ` on delete ${option2.onDelete.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option2.onUpdate ? ` on update ${option2.onUpdate.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option2.deferrable ? ` deferrable${option2.initiallyDeferred ? " initially deferred" : ""}` : ""}`);
+        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, 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;
+      default:
+        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 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}`;
+  }
+  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 renderDropIndexSql = (targetSource, ddl, state, dialect) => dialect.name === "postgres" ? `drop index${ddl.ifExists ? " if exists" : ""} ${dialect.quoteIdentifier(ddl.name)}` : `drop index ${dialect.quoteIdentifier(ddl.name)} on ${renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect)}`;
 var isExpression3 = (value) => value !== null && typeof value === "object" && (TypeId2 in value);
-var isJsonDbType = (dbType) => dbType.kind === "jsonb" || dbType.kind === "json" || ("variant" in dbType) && dbType.variant === "json";
-var isJsonExpression = (value) => isExpression3(value) && isJsonDbType(value[TypeId2].dbType);
+var isJsonDbType2 = (dbType) => {
+  if (dbType.kind === "jsonb" || dbType.kind === "json") {
+    return true;
+  }
+  if (!("variant" in dbType)) {
+    return false;
+  }
+  const variant = dbType.variant;
+  return variant === "json" || variant === "jsonb";
+};
+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",
+  numrange: "numeric",
+  tsrange: "timestamp",
+  tstzrange: "timestamptz",
+  daterange: "date",
+  int4multirange: "int4",
+  int8multirange: "int8",
+  nummultirange: "numeric",
+  tsmultirange: "timestamp",
+  tstzmultirange: "timestamptz",
+  datemultirange: "date"
+};
+var postgresRangeSubtypeKey = (dbType) => {
+  if ("base" in dbType) {
+    return postgresRangeSubtypeKey(dbType.base);
+  }
+  if ("subtype" in dbType) {
+    return postgresRangeSubtypeKey(dbType.subtype) ?? dbType.subtype.kind;
+  }
+  return postgresRangeSubtypeByKind[dbType.kind];
+};
+var assertCompatiblePostgresRangeOperands = (left, right) => {
+  const leftKey = postgresRangeSubtypeKey(left[TypeId2].dbType);
+  const rightKey = postgresRangeSubtypeKey(right[TypeId2].dbType);
+  if (leftKey !== undefined && rightKey !== undefined && leftKey !== rightKey) {
+    throw new Error("Incompatible postgres range operands");
+  }
+};
 var unsupportedJsonFeature = (dialect, feature) => {
   const error = new Error(`Unsupported JSON feature for ${dialect.name}: ${feature}`);
   Object.assign(error, {
@@ -2127,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))];
@@ -2153,21 +3730,23 @@ 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)}`;
   if (typeof segment === "string") {
-    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(segment) ? `.${segment}` : `."${segment.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+    return renderKey(segment);
   }
   if (typeof segment === "number") {
     return `[${segment}]`;
   }
   switch (segment.kind) {
     case "key":
-      return /^[A-Za-z_][A-Za-z0-9_]*$/.test(segment.key) ? `.${segment.key}` : `."${segment.key.replace(/\\/g, "\\\\").replace(/"/g, "\\\"")}"`;
+      return renderKey(segment.key);
     case "index":
       return `[${segment.index}]`;
     case "wildcard":
@@ -2210,7 +3789,7 @@ var renderPostgresJsonAccessStep = (segment, textMode, state, dialect) => {
     case "key":
       return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(segment.key, state)}`;
     case "index":
-      return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(String(segment.index), state)}`;
+      return `${textMode ? "->>" : "->"} ${dialect.renderLiteral(segment.index, state)}`;
     default:
       throw new Error("Postgres exact JSON access requires key/index segments");
   }
@@ -2219,7 +3798,7 @@ var renderPostgresJsonValue = (value, state, dialect) => {
   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)`;
@@ -2233,58 +3812,74 @@ 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 encodeArrayValues = (values, column, state, dialect) => values.map((value) => toDriverValue(value, {
-  dialect: dialect.name,
-  valueMappings: state.valueMappings,
-  dbType: column.metadata.dbType,
-  runtimeSchema: column.schema,
-  driverValueMapping: column.metadata.driverValueMapping
-}));
+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;
+  }
+  const runtimeSchemaAccepts = column.schema !== undefined && Schema5.is(column.schema)(value);
+  const normalizedValue = runtimeSchemaAccepts ? value : normalizeDbValue(column.metadata.dbType, value);
+  const encodedValue = column.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema5.decodeUnknownSync(column.schema)(normalizedValue);
+  return toDriverValue(encodedValue, {
+    dialect: dialect.name,
+    valueMappings: state.valueMappings,
+    dbType: column.metadata.dbType,
+    runtimeSchema: column.schema,
+    driverValueMapping: column.metadata.driverValueMapping
+  });
+});
 var renderPostgresJsonKind = (value) => value[TypeId2].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath = (value, state, dialect) => {
   if (isJsonPathValue(value)) {
     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 (isExpression3(value)) {
-    return renderExpression(value, state, dialect);
+    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 = isExpression3(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;
@@ -2308,7 +3903,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       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) {
@@ -2331,23 +3926,27 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       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;
@@ -2361,12 +3960,12 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         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)
@@ -2380,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})`;
@@ -2398,7 +3997,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         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":
@@ -2409,7 +4008,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         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":
@@ -2417,11 +4016,11 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         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":
@@ -2429,14 +4028,14 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         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":
@@ -2444,13 +4043,13 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         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 array(select ${objectKeys}(${baseSql})) else null end)`;
+        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":
@@ -2458,7 +4057,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         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;
@@ -2472,12 +4071,12 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         const baseSql = renderPostgresJsonValue(base, state, dialect);
         if (segments.length === 1 && (segments[0].kind === "key" || segments[0].kind === "index")) {
           const segment = segments[0];
-          return `(${baseSql} - ${segment.kind === "key" ? dialect.renderLiteral(segment.key, state) : dialect.renderLiteral(String(segment.index), state)})`;
+          return `(${baseSql} - ${segment.kind === "key" ? dialect.renderLiteral(segment.key, state) : dialect.renderLiteral(segment.index, state)})`;
         }
         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;
     }
@@ -2499,7 +4098,7 @@ 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;
     }
@@ -2515,7 +4114,7 @@ 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;
     }
@@ -2539,13 +4138,13 @@ 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 renderMysqlMutationLock = (lock, statement) => {
   if (!lock) {
@@ -2566,10 +4165,11 @@ var renderTransactionClause = (clause, dialect) => {
   switch (clause.kind) {
     case "transaction": {
       const modes = [];
-      if (clause.isolationLevel) {
-        modes.push(`isolation level ${clause.isolationLevel}`);
+      const isolationLevel = renderTransactionIsolationLevel(clause.isolationLevel);
+      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";
@@ -2579,76 +4179,115 @@ 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))}`;
   }
-  return "";
+  return "start transaction";
 };
-var renderSelectionList = (selection, state, dialect, validateAggregation) => {
-  if (validateAggregation) {
-    validateAggregationSelection(selection, []);
-  }
+var renderSelectionList = (selection, state, dialect) => {
   const flattened = flattenSelection(selection);
   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
   };
 };
-var renderQueryAst = (ast, state, dialect) => {
+var nestedRenderState = (state) => ({
+  params: state.params,
+  valueMappings: state.valueMappings,
+  casing: state.casing,
+  ctes: [],
+  cteNames: new Set(state.cteNames),
+  cteSources: new Map(state.cteSources),
+  sourceNames: new Map(state.sourceNames)
+});
+var assertSupportedMutationReturning = (dialect, selection) => {
+  if (dialect.name === "standard" && Object.keys(selection).length > 0) {
+    throw new Error("Unsupported standard returning");
+  }
+};
+var validateDistinctOnOrdering = (distinctOn, orderBy) => {
+  if (distinctOn === undefined || distinctOn.length === 0 || orderBy.length === 0) {
+    return;
+  }
+  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 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(", ")}) ${rendered.sql}` : `select${ast.distinct ? " distinct" : ""} ${rendered.sql}`
+        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) {
-        clauses.push(`${ast.lock.mode === "update" ? "for update" : "for share"}${ast.lock.nowait ? " nowait" : ""}${ast.lock.skipLocked ? " skip locked" : ""}`);
+        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" : ""}`);
       }
       sql = clauses.join(" ");
       break;
     }
     case "set": {
       const setAst = ast;
-      const base = renderQueryAst(getAst(setAst.setBase), state, dialect);
+      const base = renderQueryAst2(getAst(setAst.setBase), state, dialect);
       projections = selectionProjections(setAst.select);
       sql = [
         `(${base.sql})`,
         ...(setAst.setOperations ?? []).map((entry) => {
-          const rendered = renderQueryAst(getAst(entry.query), state, dialect);
+          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(" ");
@@ -2658,50 +4297,58 @@ var renderQueryAst = (ast, state, dialect) => {
       const insertAst = ast;
       const targetSource = insertAst.into;
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect);
+      const targetCasingState = stateWithTableCasing(state, targetSource.source);
+      const insertSource = insertAst.insertSource;
+      const conflict = expectConflictClause(insertAst.conflict);
       sql = `insert into ${target}`;
-      if (insertAst.insertSource?.kind === "values") {
-        const columns = insertAst.insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
-        const rows = insertAst.insertSource.rows.map((row) => `(${row.values.map((entry) => renderExpression(entry.value, state, dialect)).join(", ")})`).join(", ");
+      if (insertSource?.kind === "values") {
+        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 (insertAst.insertSource?.kind === "query") {
-        const columns = insertAst.insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
-        const renderedQuery = renderQueryAst(getAst(insertAst.insertSource.query), state, dialect);
+      } else if (insertSource?.kind === "query") {
+        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 (insertAst.insertSource?.kind === "unnest") {
-        const unnestSource = insertAst.insertSource;
-        const columns = unnestSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ");
+      } else if (insertSource?.kind === "unnest") {
+        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 rendered = unnestSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields[entry.columnName].metadata.dbType)}[])`).join(", ");
+          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 = unnestSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index3) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId4].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
+          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[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 (insertAst.conflict) {
-        const updateValues = (insertAst.conflict.values ?? []).map((entry) => `${dialect.quoteIdentifier(entry.columnName)} = ${renderExpression(entry.value, state, dialect)}`).join(", ");
+      if (conflict) {
+        if (dialect.name === "standard") {
+          throw new Error("Unsupported standard insert conflict");
+        }
+        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 = insertAst.conflict.target?.kind === "constraint" ? ` on conflict on constraint ${dialect.quoteIdentifier(insertAst.conflict.target.name)}` : insertAst.conflict.target?.kind === "columns" ? ` on conflict (${insertAst.conflict.target.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${insertAst.conflict.target.where ? ` where ${renderExpression(insertAst.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 += insertAst.conflict.action === "doNothing" ? " do nothing" : ` do update set ${updateValues}${insertAst.conflict.where ? ` where ${renderExpression(insertAst.conflict.where, state, dialect)}` : ""}`;
-        } else if (insertAst.conflict.action === "doNothing") {
+          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}`;
@@ -2714,11 +4361,14 @@ var renderQueryAst = (ast, state, dialect) => {
       const target = renderSourceReference(targetSource.source, targetSource.tableName, targetSource.baseTableName, state, dialect);
       const targets = updateAst.targets ?? [targetSource];
       const fromSources = updateAst.fromSources ?? [];
-      const assignments = updateAst.set.map((entry) => renderMutationAssignment(entry, state, dialect)).join(", ");
+      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, 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] : []
@@ -2736,18 +4386,19 @@ var renderQueryAst = (ast, state, dialect) => {
       }
       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}`;
@@ -2759,12 +4410,15 @@ var renderQueryAst = (ast, state, dialect) => {
       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}`;
@@ -2774,18 +4428,19 @@ var renderQueryAst = (ast, state, dialect) => {
       }
       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}`;
@@ -2794,12 +4449,18 @@ var renderQueryAst = (ast, state, dialect) => {
     }
     case "truncate": {
       const truncateAst = ast;
+      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 (truncateAst.truncate?.restartIdentity) {
+      if (restartIdentity) {
         sql += " restart identity";
       }
-      if (truncateAst.truncate?.cascade) {
+      if (cascade) {
         sql += " cascade";
       }
       break;
@@ -2811,25 +4472,27 @@ var renderQueryAst = (ast, state, dialect) => {
       const mergeAst = ast;
       const targetSource = mergeAst.target;
       const usingSource = mergeAst.using;
-      const merge = 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 ${renderExpression(merge.on, state, dialect)}`;
-      if (merge.whenMatched) {
+      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 {
-          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) {
+      if (merge2.whenNotMatched) {
         sql += " when not matched";
-        if (merge.whenNotMatched.predicate) {
-          sql += ` and ${renderExpression(merge.whenNotMatched.predicate, state, dialect)}`;
+        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;
     }
@@ -2844,27 +4507,38 @@ var renderQueryAst = (ast, state, dialect) => {
     }
     case "createTable": {
       const createTableAst = ast;
-      sql = renderCreateTableSql(createTableAst.target, state, dialect, createTableAst.ddl?.kind === "createTable" && createTableAst.ddl.ifNotExists);
+      const ddl = expectDdlClauseKind(createTableAst.ddl, "createTable");
+      sql = renderCreateTableSql(createTableAst.target, state, dialect, ddl.ifNotExists);
       break;
     }
     case "dropTable": {
       const dropTableAst = ast;
-      const ifExists = dropTableAst.ddl?.kind === "dropTable" && dropTableAst.ddl.ifExists;
+      const ddl = expectDdlClauseKind(dropTableAst.ddl, "dropTable");
+      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;
-      sql = renderCreateIndexSql(createIndexAst.target, createIndexAst.ddl, state, dialect);
+      sql = renderCreateIndexSql(createIndexAst.target, expectDdlClauseKind(createIndexAst.ddl, "createIndex"), state, dialect);
       break;
     }
     case "dropIndex": {
       const dropIndexAst = ast;
-      sql = renderDropIndexSql(dropIndexAst.target, dropIndexAst.ddl, state, dialect);
+      sql = renderDropIndexSql(dropIndexAst.target, expectDdlClauseKind(dropIndexAst.ddl, "dropIndex"), state, dialect);
+      break;
+    }
+    default: {
+      if (ast.transaction !== undefined) {
+        sql = renderTransactionClause(ast.transaction, dialect);
+      }
       break;
     }
   }
-  if (state.ctes.length === 0) {
+  if (state.ctes.length === 0 || options2.emitCtes === false) {
     return {
       sql,
       projections
@@ -2877,7 +4551,7 @@ var renderQueryAst = (ast, state, dialect) => {
 };
 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) => {
@@ -2887,9 +4561,14 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
   };
   if (typeof source === "object" && source !== null && "kind" in source && source.kind === "cte") {
     const cte = source;
+    const registeredCteSource = state.cteSources.get(cte.name);
+    if (registeredCteSource !== undefined && registeredCteSource !== cte.plan) {
+      throw new Error(`common table expression name is already registered with a different plan: ${cte.name}`);
+    }
     if (!state.cteNames.has(cte.name)) {
       state.cteNames.add(cte.name);
-      const rendered = renderQueryAst(getAst(cte.plan), state, dialect);
+      state.cteSources.set(cte.name, cte.plan);
+      const rendered = renderQueryAst2(getAst(cte.plan), state, dialect, { emitCtes: false });
       state.ctes.push({
         name: cte.name,
         sql: rendered.sql,
@@ -2901,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), 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), 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;
@@ -2920,143 +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 && 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);
   }
-  const schemaName = typeof source === "object" && source !== null && TypeId4 in source ? source[TypeId4].schemaName : undefined;
-  return dialect.renderTableReference(tableName, baseTableName, schemaName);
+  return dialect.renderTableReference(applyCategory(state.casing, "tables", tableName), applyCategory(state.casing, "tables", baseTableName), schemaName);
 };
-var renderExpression = (expression, state, dialect) => {
+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 renderQueryAst2(getAst(plan), state, dialect).sql;
+};
+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 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") {
-        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") {
-        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") {
-        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":
-      return `(${ast.values.map((value) => renderExpression(value, state, dialect)).join(" and ")})`;
+      return `(${ast.values.map((value) => renderExpression2(value, state, dialect)).join(" and ")})`;
     case "or":
-      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":
-      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":
-      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 (${renderQueryAst(getAst(ast.plan), state, dialect).sql})`;
+      return `exists (${renderSubqueryExpressionPlan(ast.plan, state, dialect)})`;
     case "scalarSubquery":
-      return `(${renderQueryAst(getAst(ast.plan), state, dialect).sql})`;
+      return `(${renderSubqueryExpressionPlan(ast.plan, state, dialect)})`;
     case "inSubquery":
-      return `(${renderExpression(ast.left, state, dialect)} in (${renderQueryAst(getAst(ast.plan), state, dialect).sql}))`;
-    case "comparisonAny":
-      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} any (${renderQueryAst(getAst(ast.plan), state, dialect).sql}))`;
-    case "comparisonAll":
-      return `(${renderExpression(ast.left, state, dialect)} ${renderComparisonOperator(ast.operator)} all (${renderQueryAst(getAst(ast.plan), state, dialect).sql}))`;
-    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) {
@@ -3067,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;
     }
@@ -3075,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,
@@ -3096,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
@@ -3123,16 +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
-}, inlineLiteralDialect);
+  cteNames: new Set,
+  cteSources: new Map
+});
+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(")")) {
@@ -3172,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 {
@@ -3182,10 +4978,14 @@ var normalizeDdlExpressionSql = (expression) => {
 };
 
 // src/postgres/schema-management.ts
-import * as Schema4 from "effect/Schema";
+import * as Schema6 from "effect/Schema";
 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 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() {
     return pipeArguments5(this, arguments);
@@ -3196,13 +4996,17 @@ var EnumProto = {
   type() {
     return {
       dialect: "postgres",
-      kind: this.qualifiedName(),
+      kind: renderQualifiedTypeName(this.name, this.schemaName),
       variant: "enum"
     };
   },
   column() {
-    const values = this.values.map((value) => Schema4.Literal(value));
-    return makeColumnDefinition(values.length === 1 ? values[0] : Schema4.Union(...values), {
+    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,
       hasDefault: false,
@@ -3210,7 +5014,7 @@ var EnumProto = {
       primaryKey: false,
       unique: false,
       references: undefined,
-      ddlType: this.qualifiedName(),
+      ddlType: renderQualifiedTypeName(this.name, this.schemaName),
       identity: undefined,
       enum: {
         name: this.name,
@@ -3255,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",
@@ -3273,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
   };
 };
@@ -3295,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 ? [] : [
     {
@@ -3311,17 +5221,17 @@ var fromDiscoveredValues = (values) => {
   const enums = new Map;
   for (const value of values) {
     if (isEnumDefinition(value)) {
-      enums.set(enumKey(value.schemaName, value.name), toEnumModel(value));
+      enums.set(modelIdentityKey(value.schemaName, value.name), toEnumModel(value));
     } else if (isTableDefinition(value)) {
       for (const enumModel of enumModelsOfTable(value)) {
-        const key2 = enumKey(enumModel.schemaName, enumModel.name);
+        const key2 = modelIdentityKey(enumModel.schemaName, enumModel.name);
         const existing = enums.get(key2);
         if (existing === undefined) {
           enums.set(key2, enumModel);
           continue;
         }
         if (JSON.stringify(existing.values) !== JSON.stringify(enumModel.values)) {
-          throw new Error(`Conflicting enum definitions discovered for '${key2}'`);
+          throw new Error(`Conflicting enum definitions discovered for '${enumKey(enumModel.schemaName, enumModel.name)}'`);
         }
       }
     }
@@ -3334,6 +5244,7 @@ var fromDiscoveredValues = (values) => {
 };
 var tableKey = (schemaName, name) => `${schemaName ?? "public"}.${name}`;
 var enumKey = (schemaName, name) => `${schemaName ?? "public"}.${name}`;
+var modelIdentityKey = (schemaName, name) => JSON.stringify([schemaName ?? "public", name]);
 export {
   toTableModel,
   toEnumModel,