effect-qb 0.19.0 → 0.21.0

package/dist/postgres/metadata.js

@@ -25,7 +25,7 @@ __export(exports_metadata, {
 });
 
 // src/internal/table.ts
-import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
 
 // src/internal/row-set.ts
 var exports_row_set = {};
@@ -35,7 +35,7 @@ __export(exports_row_set, {
 var TypeId = Symbol.for("effect-qb/Plan");
 
 // src/internal/column-state.ts
-import { pipeArguments } from "effect/Pipeable";
+import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
 import * as Schema from "effect/Schema";
 
 // src/internal/scalar.ts
@@ -48,12 +48,181 @@ var TypeId2 = Symbol.for("effect-qb/Expression");
 // src/internal/expression-ast.ts
 var TypeId3 = Symbol.for("effect-qb/ExpressionAst");
 
+// src/internal/json/path-access.ts
+import { pipeArguments } from "effect/Pipeable";
+
+// src/internal/json/path.ts
+var SegmentTypeId = Symbol.for("effect-qb/JsonPathSegment");
+var TypeId4 = Symbol.for("effect-qb/JsonPath");
+var makeSegment = (segment) => segment;
+var key = (value) => makeSegment({
+  [SegmentTypeId]: {
+    kind: "key"
+  },
+  kind: "key",
+  key: value
+});
+var index = (value) => makeSegment({
+  [SegmentTypeId]: {
+    kind: "index"
+  },
+  kind: "index",
+  index: value
+});
+var wildcard = () => makeSegment({
+  [SegmentTypeId]: {
+    kind: "wildcard"
+  },
+  kind: "wildcard"
+});
+var slice = (start, end) => makeSegment({
+  [SegmentTypeId]: {
+    kind: "slice"
+  },
+  kind: "slice",
+  start,
+  end
+});
+var descend = () => makeSegment({
+  [SegmentTypeId]: {
+    kind: "descend"
+  },
+  kind: "descend"
+});
+var path = (...segments) => ({
+  [TypeId4]: {
+    segments
+  },
+  segments
+});
+
+// src/internal/json/path-access.ts
+var WrappedTypeId = Symbol.for("effect-qb/JsonPathAccess");
+var accessKinds = new Set([
+  "jsonGet",
+  "jsonPath",
+  "jsonAccess",
+  "jsonTraverse",
+  "jsonGetText",
+  "jsonPathText",
+  "jsonAccessText",
+  "jsonTraverseText"
+]);
+var reservedKeys = new Set([
+  "pipe",
+  "then",
+  "toString",
+  "toJSON",
+  "valueOf",
+  "constructor",
+  "__proto__",
+  "prototype",
+  "inspect",
+  "schema",
+  "metadata",
+  "columns",
+  "name"
+]);
+var isObjectLike = (value) => (typeof value === "object" || typeof value === "function") && value !== null;
+var isExpression = (value) => isObjectLike(value) && (TypeId2 in value);
+var isJsonExpression = (value) => {
+  if (!isExpression(value)) {
+    return false;
+  }
+  const dbType = value[TypeId2].dbType;
+  return dbType.kind === "json" || dbType.kind === "jsonb" || dbType.variant === "json" || dbType.variant === "jsonb";
+};
+var isWrapped = (value) => value[WrappedTypeId] === true;
+var normalizeSegment = (segment) => {
+  switch (segment.kind) {
+    case "key":
+      return key(segment.key);
+    case "index":
+      return index(segment.index);
+    case "wildcard":
+      return wildcard();
+    case "slice":
+      return slice(segment.start, segment.end);
+    case "descend":
+      return descend();
+  }
+};
+var accessPathOf = (value) => {
+  const segments = [];
+  let base = value;
+  while (isExpression(base)) {
+    const ast = base[TypeId3];
+    if (ast === undefined || typeof ast.kind !== "string" || !accessKinds.has(ast.kind) || !isExpression(ast.base) || !Array.isArray(ast.segments)) {
+      break;
+    }
+    segments.unshift(...ast.segments.map(normalizeSegment));
+    base = ast.base;
+  }
+  return { base, segments };
+};
+var isIntegerProperty = (property) => /^(?:-?(?:0|[1-9][0-9]*))$/.test(property);
+var jsonAccessKind = (segments) => segments.every((segment) => segment.kind === "key" || segment.kind === "index") ? segments.length === 1 ? "jsonGet" : "jsonPath" : "jsonTraverse";
+var makeExpression = (state, ast) => {
+  const expression = Object.create(null);
+  Object.defineProperty(expression, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments(expression, arguments);
+    }
+  });
+  expression[TypeId2] = state;
+  expression[TypeId3] = ast;
+  return expression;
+};
+var makePathExpression = (value, segment) => {
+  const access = accessPathOf(value);
+  const segments = [...access.segments, normalizeSegment(segment)];
+  const base = access.base;
+  const baseState = base[TypeId2];
+  return withJsonPathAccess(makeExpression({
+    ...baseState,
+    runtime: undefined,
+    nullability: undefined
+  }, {
+    kind: jsonAccessKind(segments),
+    base,
+    segments
+  }));
+};
+var pathProxyHandler = {
+  get(target, property, receiver) {
+    if (typeof property === "symbol") {
+      return Reflect.get(target, property, receiver);
+    }
+    if (Reflect.has(target, property) || reservedKeys.has(property)) {
+      return Reflect.get(target, property, receiver);
+    }
+    const segment = isIntegerProperty(property) ? index(Number(property)) : key(property);
+    return makePathExpression(target, segment);
+  },
+  has(target, property) {
+    return Reflect.has(target, property);
+  }
+};
+var withJsonPathAccess = (value) => {
+  if (!isObjectLike(value) || !isJsonExpression(value) || isWrapped(value)) {
+    return value;
+  }
+  const proxy = new Proxy(value, pathProxyHandler);
+  Object.defineProperty(proxy, WrappedTypeId, {
+    configurable: false,
+    value: true
+  });
+  return proxy;
+};
+
 // src/internal/column-state.ts
 var ColumnTypeId = Symbol.for("effect-qb/Column");
 var BoundColumnTypeId = Symbol.for("effect-qb/BoundColumn");
 var ColumnProto = {
   pipe() {
-    return pipeArguments(this, arguments);
+    return pipeArguments2(this, arguments);
   }
 };
 var attachPipe = (value) => {
@@ -61,7 +230,7 @@ var attachPipe = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments(value, arguments);
+      return pipeArguments2(value, arguments);
     }
   });
   return value;
@@ -98,7 +267,7 @@ var makeColumnDefinition = (schema, metadata) => {
     identity: metadata.identity,
     enum: metadata.enum
   };
-  return column;
+  return withJsonPathAccess(column);
 };
 var remapColumnDefinition = (column, options = {}) => {
   const schema = options.schema ?? column.schema;
@@ -140,7 +309,7 @@ var remapColumnDefinition = (column, options = {}) => {
   if (BoundColumnTypeId in column) {
     next[BoundColumnTypeId] = column[BoundColumnTypeId];
   }
-  return next;
+  return withJsonPathAccess(next);
 };
 var bindColumn = (tableName, columnName, column, baseTableName, schemaName, casing) => {
   const brandName = `${tableName}.${columnName}`;
@@ -173,16 +342,16 @@ var bindColumn = (tableName, columnName, column, baseTableName, schemaName, casi
     schemaName,
     casing
   };
-  return bound;
+  return withJsonPathAccess(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");
+import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
+var TypeId5 = Symbol.for("effect-qb/SchemaExpression");
 var SchemaExpressionProto = {
   pipe() {
-    return pipeArguments2(this, arguments);
+    return pipeArguments3(this, arguments);
   }
 };
 var attachPipe2 = (value) => {
@@ -190,35 +359,35 @@ var attachPipe2 = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments2(value, arguments);
+      return pipeArguments3(value, arguments);
     }
   });
   return value;
 };
-var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId4 in value);
+var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId5 in value);
 var fromAst = (ast) => {
   const expression = attachPipe2(Object.create(SchemaExpressionProto));
-  expression[TypeId4] = {
+  expression[TypeId5] = {
     ast
   };
   return expression;
 };
 var fromSql = (sql) => {
   const expression = attachPipe2(Object.create(SchemaExpressionProto));
-  expression[TypeId4] = {
+  expression[TypeId5] = {
     sql: sql.trim()
   };
   return expression;
 };
 var parseExpression = (sql) => fromAst(parse(sql, "expr"));
 var toAst = (expression) => {
-  const ast = expression[TypeId4].ast;
+  const ast = expression[TypeId5].ast;
   if (ast !== undefined) {
     return ast;
   }
   return parse(render(expression), "expr");
 };
-var render = (expression) => expression[TypeId4].sql ?? toSql.expr(toAst(expression));
+var render = (expression) => expression[TypeId5].sql ?? toSql.expr(toAst(expression));
 var normalize = (expression) => (() => {
   const sql = render(expression);
   try {
@@ -313,7 +482,7 @@ var collectInlineOptions = (fields) => {
   return options;
 };
 var resolvePrimaryKeyColumns = (fields, declaredOptions) => {
-  const inline = Object.entries(fields).filter(([, column]) => column.metadata.primaryKey).map(([key]) => key);
+  const inline = Object.entries(fields).filter(([, column]) => column.metadata.primaryKey).map(([key2]) => key2);
   const explicit = declaredOptions.flatMap((option) => {
     if (typeof option !== "object" || option === null || !("kind" in option) || option.kind !== "primaryKey") {
       return [];
@@ -339,8 +508,8 @@ var validateOptions = (tableName, fields, options) => {
       case "foreignKey": {
         if (option.kind === "index") {
           const keys = Array.isArray(option.keys) ? option.keys : [];
-          for (const key of keys) {
-            if (typeof key !== "object" || key === null || !("kind" in key)) {
+          for (const key2 of keys) {
+            if (typeof key2 !== "object" || key2 === null || !("kind" in key2)) {
               continue;
             }
           }
@@ -387,10 +556,10 @@ var fieldSchemaForVariant = (variant, column, tableName, columnName, primaryKeyS
 var deriveSchema = (variant, tableName, fields, primaryKeyColumns) => {
   const primaryKeySet = new Set(primaryKeyColumns);
   const structFields = {};
-  for (const [key, column] of Object.entries(fields)) {
-    const schema = fieldSchemaForVariant(variant, column, tableName, key, primaryKeySet);
+  for (const [key2, column] of Object.entries(fields)) {
+    const schema = fieldSchemaForVariant(variant, column, tableName, key2, primaryKeySet);
     if (schema !== undefined) {
-      structFields[key] = schema;
+      structFields[key2] = schema;
     }
   }
   return Schema2.Struct(structFields);
@@ -400,7 +569,7 @@ var deriveInsertSchema = (tableName, fields, primaryKeyColumns) => deriveSchema(
 var deriveUpdateSchema = (tableName, fields, primaryKeyColumns) => deriveSchema("update", tableName, fields, primaryKeyColumns);
 
 // src/internal/casing.ts
-var TypeId5 = Symbol.for("effect-qb/Casing");
+var TypeId6 = Symbol.for("effect-qb/Casing");
 var merge = (base, override) => {
   if (base === undefined) {
     return override;
@@ -441,15 +610,16 @@ var apply = (style, name) => {
 var applyCategory = (options, category, name) => apply(options?.[category], name);
 
 // src/internal/table.ts
-var TypeId6 = Symbol.for("effect-qb/Table");
+var TypeId7 = 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 ResolveOptionSymbol = Symbol.for("effect-qb/Table/resolveOption");
 var TableProto = {
   pipe() {
-    return pipeArguments3(this, arguments);
+    return pipeArguments4(this, arguments);
   }
 };
 var attachPipe3 = (value) => {
@@ -457,21 +627,50 @@ var attachPipe3 = (value) => {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments3(value, arguments);
+      return pipeArguments4(value, arguments);
     }
   });
   return value;
 };
+var conflictArbitersFromOptions = (options2) => options2.flatMap((option) => {
+  if (typeof option !== "object" || option === null) {
+    return [];
+  }
+  if (!("columns" in option) || !Array.isArray(option.columns) || option.columns.length === 0) {
+    return [];
+  }
+  switch (option.kind) {
+    case "primaryKey":
+    case "unique":
+      return [{
+        columns: option.columns,
+        scope: "unconditional",
+        name: option.name,
+        constraint: true
+      }];
+    case "index":
+      return option.unique === true ? [{
+        columns: option.columns,
+        scope: option.predicate === undefined ? "unconditional" : "partial",
+        name: option.name,
+        constraint: false
+      }] : [];
+    default:
+      return [];
+  }
+});
 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, casing)]));
+  const conflictArbiters = conflictArbitersFromOptions(normalizedOptions);
+  const columns = Object.fromEntries(Object.entries(fields).map(([key2, column]) => [key2, bindColumn(name, key2, column, name, schemaName, casing)]));
   return {
     columns,
     normalizedOptions,
-    primaryKey
+    primaryKey,
+    conflictArbiters
   };
 };
 var getSchemaCache = (table) => {
@@ -487,7 +686,7 @@ var getSchemaCache = (table) => {
   return cache;
 };
 var deriveTableSchema = (table, variant) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   switch (variant) {
     case "select":
       return deriveSelectSchema(state.name, state.fields, state.primaryKey);
@@ -556,12 +755,13 @@ var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema"
   table.name = name;
   table.columns = artifacts.columns;
   defineSchemasGetter(table);
-  table[TypeId6] = {
+  table[TypeId7] = {
     name,
     baseName,
     schemaName: resolvedSchemaName,
     fields,
     primaryKey: artifacts.primaryKey,
+    conflictArbiters: artifacts.conflictArbiters,
     kind,
     casing
   };
@@ -579,8 +779,8 @@ var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema"
   };
   table[OptionsSymbol] = artifacts.normalizedOptions;
   table[DeclaredOptionsSymbol] = declaredOptions;
-  for (const [key, value] of Object.entries(artifacts.columns)) {
-    Object.defineProperty(table, key, {
+  for (const [key2, value] of Object.entries(artifacts.columns)) {
+    Object.defineProperty(table, key2, {
       enumerable: true,
       value
     });
@@ -618,13 +818,14 @@ var ensureClassArtifacts = (self) => {
   if (cached) {
     return cached;
   }
-  const state = self[TypeId6];
+  const state = self[TypeId7];
   const classOptions = self[options];
   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,
     normalizedOptions: table[OptionsSymbol],
-    primaryKey: table[TypeId6].primaryKey
+    primaryKey: table[TypeId7].primaryKey,
+    conflictArbiters: table[TypeId7].conflictArbiters
   };
   Object.defineProperty(self, CacheSymbol, {
     configurable: true,
@@ -633,38 +834,54 @@ var ensureClassArtifacts = (self) => {
   return artifacts;
 };
 var appendOption = (table, option) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   return makeTable(state.name, state.fields, [...table[DeclaredOptionsSymbol], option], state.baseName, state.kind, state.schemaName, "explicit", state.casing);
 };
 var makeOption = (option) => {
   return attachPipe3(Object.assign((table, ..._validation) => appendOption(table, option), { option }));
 };
+var makeResolvedOption = (option, resolve) => {
+  return attachPipe3(Object.assign((table, ..._validation) => appendOption(table, resolve(table)), {
+    option,
+    [ResolveOptionSymbol]: resolve
+  }));
+};
 var option = (spec) => makeOption(spec);
+var optionFromTable = (spec, resolve) => makeResolvedOption(spec, resolve);
+var resolveOption = (option2, table) => {
+  const resolve = option2[ResolveOptionSymbol];
+  return resolve === undefined ? option2.option : resolve(table);
+};
+var mapOption = (option2, map) => {
+  const resolve = option2[ResolveOptionSymbol];
+  return resolve === undefined ? makeOption(map(option2.option)) : makeResolvedOption(map(option2.option), (table) => map(resolve(table)));
+};
 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 withCasing = (table, casing) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   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];
+  const state = table[TypeId7];
   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[TypeId6];
-  const columns = Object.fromEntries(Object.entries(state.fields).map(([key, column]) => [key, bindColumn(aliasName, key, column, state.baseName, state.schemaName, state.casing)]));
+  const state = table[TypeId7];
+  const columns = Object.fromEntries(Object.entries(state.fields).map(([key2, column]) => [key2, bindColumn(aliasName, key2, column, state.baseName, state.schemaName, state.casing)]));
   const aliased = attachPipe3(Object.create(TableProto));
   aliased.name = aliasName;
   aliased.columns = columns;
   defineSchemasGetter(aliased);
-  aliased[TypeId6] = {
+  aliased[TypeId7] = {
     name: aliasName,
     baseName: state.baseName,
     schemaName: state.schemaName,
     fields: state.fields,
     primaryKey: state.primaryKey,
+    conflictArbiters: state.conflictArbiters,
     kind: "alias",
     casing: state.casing
   };
@@ -682,8 +899,8 @@ var alias = (table, aliasName) => {
   };
   aliased[OptionsSymbol] = table[OptionsSymbol];
   aliased[DeclaredOptionsSymbol] = table[DeclaredOptionsSymbol];
-  for (const [key, value] of Object.entries(columns)) {
-    Object.defineProperty(aliased, key, {
+  for (const [key2, value] of Object.entries(columns)) {
+    Object.defineProperty(aliased, key2, {
       enumerable: true,
       value
     });
@@ -702,14 +919,16 @@ function Class(name, schemaName) {
       static get schemas() {
         return schemasFor(this);
       }
-      static get [TypeId6]() {
+      static get [TypeId7]() {
         const declaredOptions = extractDeclaredOptions(this[options]);
+        const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions];
         return {
           name,
           baseName: name,
           schemaName: resolvedSchemaName,
           fields,
           primaryKey: resolvePrimaryKeyColumns(fields, collectInlineOptions(fields)),
+          conflictArbiters: conflictArbitersFromOptions(normalizedOptions),
           kind: "schema"
         };
       }
@@ -732,49 +951,83 @@ function Class(name, schemaName) {
         return ensureClassArtifacts(this).normalizedOptions;
       }
       static pipe() {
-        return pipeArguments3(this, arguments);
+        return pipeArguments4(this, arguments);
       }
     }
-    for (const key of Object.keys(fields)) {
-      Object.defineProperty(TableClassBase, key, {
+    for (const key2 of Object.keys(fields)) {
+      Object.defineProperty(TableClassBase, key2, {
         enumerable: true,
         configurable: true,
         get() {
-          return ensureClassArtifacts(this).columns[key];
+          return ensureClassArtifacts(this).columns[key2];
         }
       });
     }
     return TableClassBase;
   };
 }
-var primaryKey = (columns) => makeOption({
-  kind: "primaryKey",
-  columns: normalizeColumnList(columns)
-});
-var unique = (columns) => makeOption({
-  kind: "unique",
-  columns: normalizeColumnList(columns)
-});
-var index = (columns) => makeOption({
-  kind: "index",
-  columns: normalizeColumnList(columns)
-});
-var foreignKey = (columns, target, referencedColumns) => makeOption({
-  kind: "foreignKey",
-  columns: normalizeColumnList(columns),
-  references: () => ({
-    tableName: target()[TypeId6].baseName,
-    schemaName: target()[TypeId6].schemaName,
-    casing: target()[TypeId6].casing,
-    columns: normalizeColumnList(referencedColumns),
-    knownColumns: Object.keys(target()[TypeId6].fields).map((key) => key)
-  })
-});
-var check = (name, predicate) => makeOption({
-  kind: "check",
-  name,
-  predicate
-});
+var selectionArray = (selection) => Array.isArray(selection) ? selection : [selection];
+var selectedColumnList = (selection) => selectionArray(selection).map((column) => column[BoundColumnTypeId].columnName);
+var referenceFromSelection = (selection) => {
+  const columns = selectionArray(selection);
+  const first = columns[0];
+  const bound = first[BoundColumnTypeId];
+  return {
+    tableName: bound.baseTableName,
+    schemaName: bound.schemaName,
+    casing: bound.casing,
+    columns: columns.map((column) => column[BoundColumnTypeId].columnName)
+  };
+};
+function primaryKey(columns) {
+  return makeResolvedOption({
+    kind: "primaryKey",
+    columns: []
+  }, (table) => ({
+    kind: "primaryKey",
+    columns: selectedColumnList(columns(table))
+  }));
+}
+function unique(columns) {
+  return makeResolvedOption({
+    kind: "unique",
+    columns: []
+  }, (table) => ({
+    kind: "unique",
+    columns: selectedColumnList(columns(table))
+  }));
+}
+function index2(columns) {
+  return makeResolvedOption({
+    kind: "index",
+    columns: []
+  }, (table) => ({
+    kind: "index",
+    columns: selectedColumnList(columns(table))
+  }));
+}
+function foreignKey(columns, target) {
+  return makeResolvedOption({
+    kind: "foreignKey",
+    columns: [],
+    references: () => referenceFromSelection(target())
+  }, (table) => ({
+    kind: "foreignKey",
+    columns: selectedColumnList(columns(table)),
+    references: () => referenceFromSelection(target())
+  }));
+}
+function check(name, predicate) {
+  const spec = {
+    kind: "check",
+    name,
+    predicate
+  };
+  return typeof predicate === "function" ? makeResolvedOption(spec, (table) => ({
+    ...spec,
+    predicate: predicate(table)
+  })) : makeOption(spec);
+}
 
 // src/internal/sql-expression-renderer.ts
 var renderQueryAst = (ast, state, dialect) => {
@@ -800,10 +1053,10 @@ var renderDbTypeName = (value) => value;
 import * as Schema5 from "effect/Schema";
 
 // src/internal/query.ts
-import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments5 } from "effect/Pipeable";
 
 // src/internal/query-ast.ts
-var TypeId7 = Symbol.for("effect-qb/QueryAst");
+var TypeId8 = Symbol.for("effect-qb/QueryAst");
 
 // src/internal/predicate/runtime.ts
 var trueFormula = () => ({ kind: "true" });
@@ -828,17 +1081,17 @@ var cloneContext = (context) => ({
   nonNullKeys: new Set(context.nonNullKeys),
   nullKeys: new Set(context.nullKeys),
   eqLiterals: new Map(context.eqLiterals),
-  neqLiterals: new Map(Array.from(context.neqLiterals.entries(), ([key, values]) => [key, new Set(values)])),
-  literalSets: new Map(Array.from(context.literalSets.entries(), ([key, values]) => [key, new Set(values)])),
+  neqLiterals: new Map(Array.from(context.neqLiterals.entries(), ([key2, values]) => [key2, new Set(values)])),
+  literalSets: new Map(Array.from(context.literalSets.entries(), ([key2, values]) => [key2, new Set(values)])),
   sourceNames: new Set(context.sourceNames),
   contradiction: context.contradiction,
   unknown: context.unknown
 });
 var freezeContext = (context) => context;
 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);
+var columnPredicateKeyParts = (key2) => {
+  const jsonSeparator = key2.indexOf("#json:");
+  const columnKey = jsonSeparator === -1 ? key2 : key2.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;
@@ -846,59 +1099,59 @@ var columnPredicateKeyParts = (key) => {
     return;
   }
 };
-var sourceNameOfKey = (key) => columnPredicateKeyParts(key)?.[0] ?? key.split(".", 1)[0] ?? key;
-var addSourceName = (context, key) => {
-  context.sourceNames.add(sourceNameOfKey(key));
+var sourceNameOfKey = (key2) => columnPredicateKeyParts(key2)?.[0] ?? key2.split(".", 1)[0] ?? key2;
+var addSourceName = (context, key2) => {
+  context.sourceNames.add(sourceNameOfKey(key2));
 };
-var addNonNull = (context, key) => {
-  addSourceName(context, key);
-  if (context.nullKeys.has(key)) {
+var addNonNull = (context, key2) => {
+  addSourceName(context, key2);
+  if (context.nullKeys.has(key2)) {
     context.contradiction = true;
   }
-  context.nonNullKeys.add(key);
+  context.nonNullKeys.add(key2);
 };
-var addNull = (context, key) => {
-  addSourceName(context, key);
-  if (context.nonNullKeys.has(key)) {
+var addNull = (context, key2) => {
+  addSourceName(context, key2);
+  if (context.nonNullKeys.has(key2)) {
     context.contradiction = true;
   }
-  context.nullKeys.add(key);
+  context.nullKeys.add(key2);
 };
-var addEqLiteral = (context, key, value) => {
-  addNonNull(context, key);
-  const existing = context.eqLiterals.get(key);
+var addEqLiteral = (context, key2, value) => {
+  addNonNull(context, key2);
+  const existing = context.eqLiterals.get(key2);
   if (existing !== undefined && existing !== value) {
     context.contradiction = true;
   }
-  const neqValues = context.neqLiterals.get(key);
+  const neqValues = context.neqLiterals.get(key2);
   if (neqValues?.has(value)) {
     context.contradiction = true;
   }
-  const existingSet = context.literalSets.get(key);
+  const existingSet = context.literalSets.get(key2);
   if (existingSet !== undefined && !existingSet.has(value)) {
     context.contradiction = true;
   }
-  context.eqLiterals.set(key, value);
-  context.literalSets.set(key, new Set([value]));
+  context.eqLiterals.set(key2, value);
+  context.literalSets.set(key2, new Set([value]));
 };
-var addNeqLiteral = (context, key, value) => {
-  addNonNull(context, key);
-  if (context.eqLiterals.get(key) === value) {
+var addNeqLiteral = (context, key2, value) => {
+  addNonNull(context, key2);
+  if (context.eqLiterals.get(key2) === value) {
     context.contradiction = true;
   }
-  const values = context.neqLiterals.get(key) ?? new Set;
+  const values = context.neqLiterals.get(key2) ?? new Set;
   values.add(value);
-  context.neqLiterals.set(key, values);
+  context.neqLiterals.set(key2, values);
 };
-var addLiteralSet = (context, key, values) => {
-  addNonNull(context, key);
-  const existingEq = context.eqLiterals.get(key);
+var addLiteralSet = (context, key2, values) => {
+  addNonNull(context, key2);
+  const existingEq = context.eqLiterals.get(key2);
   if (existingEq !== undefined && !values.has(existingEq)) {
     context.contradiction = true;
   }
-  const existing = context.literalSets.get(key);
-  context.literalSets.set(key, existing === undefined ? new Set(values) : new Set(Array.from(existing).filter((value) => values.has(value))));
-  if (context.literalSets.get(key)?.size === 0) {
+  const existing = context.literalSets.get(key2);
+  context.literalSets.set(key2, existing === undefined ? new Set(values) : new Set(Array.from(existing).filter((value) => values.has(value))));
+  if (context.literalSets.get(key2)?.size === 0) {
     context.contradiction = true;
   }
 };
@@ -980,35 +1233,35 @@ var applyNegativeAtom = (context, atom) => {
 };
 var intersectEqLiterals = (left, right) => {
   const result = new Map;
-  for (const [key, value] of left) {
-    if (right.get(key) === value) {
-      result.set(key, value);
+  for (const [key2, value] of left) {
+    if (right.get(key2) === value) {
+      result.set(key2, value);
     }
   }
   return result;
 };
 var intersectNeqLiterals = (left, right) => {
   const result = new Map;
-  for (const [key, leftValues] of left) {
-    const rightValues = right.get(key);
+  for (const [key2, leftValues] of left) {
+    const rightValues = right.get(key2);
     if (rightValues === undefined) {
       continue;
     }
     const next = new Set(Array.from(leftValues).filter((value) => rightValues.has(value)));
     if (next.size > 0) {
-      result.set(key, next);
+      result.set(key2, next);
     }
   }
   return result;
 };
 var unionLiteralSets = (left, right) => {
   const result = new Map;
-  for (const [key, leftValues] of left) {
-    const rightValues = right.get(key);
+  for (const [key2, leftValues] of left) {
+    const rightValues = right.get(key2);
     if (rightValues === undefined) {
       continue;
     }
-    result.set(key, new Set([...leftValues, ...rightValues]));
+    result.set(key2, new Set([...leftValues, ...rightValues]));
   }
   return result;
 };
@@ -1020,8 +1273,8 @@ var intersectContexts = (left, right) => {
     return cloneContext(left);
   }
   return {
-    nonNullKeys: new Set(Array.from(left.nonNullKeys).filter((key) => right.nonNullKeys.has(key))),
-    nullKeys: new Set(Array.from(left.nullKeys).filter((key) => right.nullKeys.has(key))),
+    nonNullKeys: new Set(Array.from(left.nonNullKeys).filter((key2) => right.nonNullKeys.has(key2))),
+    nullKeys: new Set(Array.from(left.nullKeys).filter((key2) => right.nullKeys.has(key2))),
     eqLiterals: intersectEqLiterals(left.eqLiterals, right.eqLiterals),
     neqLiterals: intersectNeqLiterals(left.neqLiterals, right.neqLiterals),
     literalSets: unionLiteralSets(left.literalSets, right.literalSets),
@@ -1112,18 +1365,18 @@ var jsonPathPredicateKeyOfExpression = (value) => {
       if (segments.length === 0 || segments.length > 8) {
         return;
       }
-      const path = [];
+      const path2 = [];
       for (const segment of segments) {
         if (typeof segment !== "object" || segment === null || segment.kind !== "key") {
           return;
         }
-        path.push(segment.key);
+        path2.push(segment.key);
       }
-      if (path.length === 0) {
+      if (path2.length === 0) {
         return;
       }
       const baseKey = columnKeyOfExpression(jsonAst.base);
-      return baseKey === undefined ? undefined : `${baseKey}#json:${path.map(escapeJsonPathPredicateKeySegment).join(".")}`;
+      return baseKey === undefined ? undefined : `${baseKey}#json:${path2.map(escapeJsonPathPredicateKeySegment).join(".")}`;
     }
     default:
       return;
@@ -1160,8 +1413,8 @@ var valueKeyOfLiteral = (value) => {
   return "unknown";
 };
 var nonNullFactsOfExpression = (value) => {
-  const key = predicateKeyOfExpression(value);
-  return key === undefined ? undefined : atomFormula({ kind: "is-not-null", key });
+  const key2 = predicateKeyOfExpression(value);
+  return key2 === undefined ? undefined : atomFormula({ kind: "is-not-null", key: key2 });
 };
 var combineFacts = (left, right) => {
   if (left === undefined) {
@@ -1372,12 +1625,12 @@ var formulaOfExpression = (value) => {
       }
       return unknownTag("literal:non-boolean");
     case "isNull": {
-      const key = predicateKeyOfExpression(ast.value);
-      return key === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key });
+      const key2 = predicateKeyOfExpression(ast.value);
+      return key2 === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key: key2 });
     }
     case "isNotNull": {
-      const key = predicateKeyOfExpression(ast.value);
-      return key === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key });
+      const key2 = predicateKeyOfExpression(ast.value);
+      return key2 === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key: key2 });
     }
     case "not":
       return notFormula(formulaOfExpression(ast.value));
@@ -1398,12 +1651,12 @@ var formulaOfExpression = (value) => {
       if (left === undefined) {
         return falseFormula();
       }
-      const key = predicateKeyOfExpression(left);
+      const key2 = predicateKeyOfExpression(left);
       const literalValues = rest.map((entry) => {
         const entryAst = astOf(entry);
         return entryAst.kind === "literal" && entryAst.value !== null ? valueKeyOfLiteral(entryAst.value) : undefined;
       });
-      return key !== undefined && literalValues.every((entry) => entry !== undefined) ? atomFormula({ kind: "literal-set", key, values: literalValues }) : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
+      return key2 !== undefined && literalValues.every((entry) => entry !== undefined) ? atomFormula({ kind: "literal-set", key: key2, values: literalValues }) : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
     }
     case "notIn": {
       const [left, ...rest] = ast.values;
@@ -1440,12 +1693,12 @@ var union_query_capabilities = (...values) => [...new Set(values.flatMap((value)
 // src/internal/query.ts
 var ExpressionProto = {
   pipe() {
-    return pipeArguments4(this, arguments);
+    return pipeArguments5(this, arguments);
   }
 };
 var PlanProto = {
   pipe() {
-    return pipeArguments4(this, arguments);
+    return pipeArguments5(this, arguments);
   }
 };
 var QueryTypeId = Symbol.for("effect-qb/Query/internal");
@@ -1458,13 +1711,13 @@ var mergeAggregationManyRuntime = (values) => values.reduce((current, value) =>
 var mergeNullabilityRuntime = (left, right = "never") => left === "always" || right === "always" ? "always" : left === "maybe" || right === "maybe" ? "maybe" : "never";
 var mergeNullabilityManyRuntime = (values) => values.reduce((current, value) => mergeNullabilityRuntime(current, value[TypeId2].nullability), "never");
 var mergeManyDependencies = (values) => values.reduce((current, value) => mergeDependencies(current, value[TypeId2].dependencies), {});
-var makeExpression = (state, ast) => {
+var makeExpression2 = (state, ast) => {
   const expression = Object.create(ExpressionProto);
   Object.defineProperty(expression, "pipe", {
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments4(expression, arguments);
+      return pipeArguments5(expression, arguments);
     }
   });
   expression[TypeId2] = {
@@ -1486,11 +1739,11 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
     configurable: true,
     writable: true,
     value: function() {
-      return pipeArguments4(plan, arguments);
+      return pipeArguments5(plan, arguments);
     }
   });
   plan[TypeId] = state;
-  plan[TypeId7] = ast;
+  plan[TypeId8] = ast;
   plan[QueryTypeId] = {
     required: undefined,
     availableNames: undefined,
@@ -1504,7 +1757,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
   };
   return plan;
 };
-var getAst = (plan) => plan[TypeId7];
+var getAst = (plan) => plan[TypeId8];
 var getQueryState = (plan) => plan[QueryTypeId];
 var extractRequiredRuntime = (selection) => {
   const required = new Set;
@@ -1528,50 +1781,863 @@ var extractSingleSelectedExpressionRuntime = (selection) => {
 };
 var currentRequiredList = (required) => Array.isArray(required) ? [...required] : required === undefined ? [] : [required];
 
-// src/internal/json/path.ts
-var SegmentTypeId = Symbol.for("effect-qb/JsonPathSegment");
-var TypeId8 = Symbol.for("effect-qb/JsonPath");
-var makeSegment = (segment) => segment;
-var key = (value) => makeSegment({
-  [SegmentTypeId]: {
-    kind: "key"
+// src/internal/datatypes/matrix.ts
+var portableDatatypeFamilies = {
+  uuid: {
+    compareGroup: "uuid",
+    castTargets: ["uuid", "char", "varchar", "text"],
+    traits: {
+      textual: true
+    }
   },
-  kind: "key",
-  key: value
-});
-var index2 = (value) => makeSegment({
-  [SegmentTypeId]: {
-    kind: "index"
+  text: {
+    compareGroup: "text",
+    castTargets: [
+      "text",
+      "numeric",
+      "integer",
+      "real",
+      "boolean",
+      "date",
+      "time",
+      "datetime",
+      "interval",
+      "uuid",
+      "json",
+      "blob",
+      "binary",
+      "array",
+      "range",
+      "multirange",
+      "record",
+      "enum",
+      "set",
+      "money",
+      "null"
+    ],
+    traits: {
+      textual: true,
+      ordered: true
+    }
   },
-  kind: "index",
-  index: value
-});
-var wildcard = () => makeSegment({
-  [SegmentTypeId]: {
-    kind: "wildcard"
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
   },
-  kind: "wildcard"
-});
-var slice = (start, end) => makeSegment({
-  [SegmentTypeId]: {
-    kind: "slice"
+  integer: {
+    compareGroup: "numeric",
+    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
   },
-  kind: "slice",
-  start,
-  end
-});
-var descend = () => makeSegment({
-  [SegmentTypeId]: {
-    kind: "descend"
+  real: {
+    compareGroup: "numeric",
+    castTargets: ["real", "numeric", "integer", "text", "boolean"],
+    traits: {
+      ordered: true
+    }
   },
-  kind: "descend"
-});
-var path = (...segments) => ({
-  [TypeId8]: {
-    segments
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "integer", "numeric", "text"],
+    traits: {}
   },
-  segments
-});
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  datetime: {
+    compareGroup: "datetime",
+    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  blob: {
+    compareGroup: "blob",
+    castTargets: ["blob", "text"],
+    traits: {}
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: ["uuid", "text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {}
+  }
+};
+var portableDatatypeKinds = {
+  uuid: { family: "uuid", runtime: "string" },
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  int: { family: "integer", runtime: "number" },
+  integer: { family: "integer", runtime: "number" },
+  bigint: { family: "integer", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  decimal: { family: "numeric", runtime: "decimalString" },
+  real: { family: "real", runtime: "number" },
+  boolean: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  datetime: { family: "datetime", runtime: "localDateTime" },
+  timestamp: { family: "datetime", runtime: "localDateTime" },
+  json: { family: "json", runtime: "json" },
+  blob: { family: "blob", runtime: "bytes" }
+};
+var portableDatatypeKeys = Object.keys(portableDatatypeKinds);
+var portableDatatypeDdlTypeByDialect = {
+  standard: {
+    uuid: "uuid",
+    text: "text",
+    varchar: "varchar",
+    char: "char",
+    int: "int",
+    integer: "integer",
+    bigint: "bigint",
+    numeric: "numeric",
+    decimal: "decimal",
+    real: "real",
+    boolean: "boolean",
+    date: "date",
+    time: "time",
+    datetime: "datetime",
+    timestamp: "timestamp",
+    json: "json",
+    blob: "blob"
+  },
+  postgres: {
+    uuid: "uuid",
+    text: "text",
+    varchar: "varchar",
+    char: "char",
+    int: "int",
+    integer: "integer",
+    bigint: "bigint",
+    numeric: "numeric",
+    decimal: "decimal",
+    real: "real",
+    boolean: "boolean",
+    date: "date",
+    time: "time",
+    datetime: "timestamp",
+    timestamp: "timestamp",
+    json: "json",
+    blob: "bytea"
+  },
+  mysql: {
+    uuid: "char(36)",
+    text: "text",
+    varchar: "varchar(255)",
+    char: "char",
+    int: "int",
+    integer: "integer",
+    bigint: "bigint",
+    numeric: "numeric",
+    decimal: "decimal",
+    real: "real",
+    boolean: "boolean",
+    date: "date",
+    time: "time",
+    datetime: "datetime",
+    timestamp: "timestamp",
+    json: "json",
+    blob: "blob"
+  },
+  sqlite: {
+    uuid: "text",
+    text: "text",
+    varchar: "varchar",
+    char: "char",
+    int: "int",
+    integer: "integer",
+    bigint: "bigint",
+    numeric: "numeric",
+    decimal: "decimal",
+    real: "real",
+    boolean: "boolean",
+    date: "date",
+    time: "time",
+    datetime: "datetime",
+    timestamp: "datetime",
+    json: "json",
+    blob: "blob"
+  }
+};
+var portableDatatypeCastTypeByDialect = {
+  standard: portableDatatypeDdlTypeByDialect.standard,
+  postgres: portableDatatypeDdlTypeByDialect.postgres,
+  mysql: {
+    ...portableDatatypeDdlTypeByDialect.mysql,
+    uuid: "char(36)",
+    text: "char",
+    varchar: "char",
+    char: "char",
+    int: "signed",
+    integer: "signed",
+    bigint: "signed",
+    numeric: "decimal",
+    decimal: "decimal",
+    boolean: "unsigned",
+    datetime: "datetime",
+    timestamp: "datetime",
+    blob: "binary"
+  },
+  sqlite: {
+    ...portableDatatypeDdlTypeByDialect.sqlite,
+    uuid: "text",
+    int: "integer",
+    timestamp: "datetime"
+  }
+};
+var hasOwn = (value, key2) => Object.prototype.hasOwnProperty.call(value, key2);
+var renderPortableDatatypeDdlType = (dialect, kind) => {
+  if (!hasOwn(portableDatatypeDdlTypeByDialect, dialect)) {
+    return;
+  }
+  const byKind = portableDatatypeDdlTypeByDialect[dialect];
+  return hasOwn(byKind, kind) ? byKind[kind] : undefined;
+};
+var renderPortableDatatypeCastType = (dialect, kind) => {
+  if (!hasOwn(portableDatatypeCastTypeByDialect, dialect)) {
+    return;
+  }
+  const byKind = portableDatatypeCastTypeByDialect[dialect];
+  return hasOwn(byKind, kind) ? byKind[kind] : undefined;
+};
+var postgresDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "timestamp",
+      "interval",
+      "binary",
+      "uuid",
+      "json",
+      "xml",
+      "bit",
+      "oid",
+      "identifier",
+      "network",
+      "spatial",
+      "textsearch",
+      "range",
+      "multirange",
+      "array",
+      "money",
+      "null"
+    ],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "text", "boolean", "date", "time", "timestamp", "interval", "uuid", "bit", "oid", "money"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "text", "numeric"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  timestamp: {
+    compareGroup: "timestamp",
+    castTargets: ["timestamp", "date", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  interval: {
+    compareGroup: "interval",
+    castTargets: ["interval", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  binary: {
+    compareGroup: "binary",
+    castTargets: ["binary", "text"],
+    traits: {}
+  },
+  uuid: {
+    compareGroup: "uuid",
+    castTargets: ["uuid", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  xml: {
+    compareGroup: "xml",
+    castTargets: ["xml", "text"],
+    traits: {}
+  },
+  bit: {
+    compareGroup: "bit",
+    castTargets: ["bit", "text", "numeric"],
+    traits: {}
+  },
+  oid: {
+    compareGroup: "oid",
+    castTargets: ["oid", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  identifier: {
+    compareGroup: "identifier",
+    castTargets: ["identifier", "text"],
+    traits: {}
+  },
+  network: {
+    compareGroup: "network",
+    castTargets: ["network", "text"],
+    traits: {}
+  },
+  spatial: {
+    compareGroup: "spatial",
+    castTargets: ["spatial", "text"],
+    traits: {}
+  },
+  textsearch: {
+    compareGroup: "textsearch",
+    castTargets: ["textsearch", "text"],
+    traits: {}
+  },
+  range: {
+    compareGroup: "range",
+    castTargets: ["range", "text"],
+    traits: {}
+  },
+  multirange: {
+    compareGroup: "multirange",
+    castTargets: ["multirange", "text"],
+    traits: {}
+  },
+  enum: {
+    compareGroup: "enum",
+    castTargets: ["enum", "text"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  record: {
+    compareGroup: "record",
+    castTargets: ["record", "text"],
+    traits: {}
+  },
+  array: {
+    compareGroup: "array",
+    castTargets: ["array", "text"],
+    traits: {}
+  },
+  money: {
+    compareGroup: "money",
+    castTargets: ["money", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "timestamp",
+      "interval",
+      "binary",
+      "uuid",
+      "json",
+      "xml",
+      "bit",
+      "oid",
+      "identifier",
+      "network",
+      "spatial",
+      "textsearch",
+      "range",
+      "multirange",
+      "array",
+      "money",
+      "null"
+    ],
+    traits: {}
+  }
+};
+var postgresDatatypeKinds = {
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  citext: { family: "text", runtime: "string" },
+  name: { family: "text", runtime: "string" },
+  uuid: { family: "uuid", runtime: "string" },
+  int2: { family: "numeric", runtime: "number" },
+  int4: { family: "numeric", runtime: "number" },
+  int8: { family: "numeric", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  float4: { family: "numeric", runtime: "number" },
+  float8: { family: "numeric", runtime: "number" },
+  money: { family: "money", runtime: "number" },
+  bool: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  timetz: { family: "time", runtime: "offsetTime" },
+  timestamp: { family: "timestamp", runtime: "localDateTime" },
+  timestamptz: { family: "timestamp", runtime: "instant" },
+  interval: { family: "interval", runtime: "string" },
+  bytea: { family: "binary", runtime: "bytes" },
+  json: { family: "json", runtime: "json" },
+  jsonb: { family: "json", runtime: "json" },
+  xml: { family: "xml", runtime: "string" },
+  bit: { family: "bit", runtime: "string" },
+  varbit: { family: "bit", runtime: "string" },
+  oid: { family: "oid", runtime: "number" },
+  xid: { family: "oid", runtime: "number" },
+  xid8: { family: "oid", runtime: "bigintString" },
+  cid: { family: "oid", runtime: "number" },
+  tid: { family: "identifier", runtime: "string" },
+  regclass: { family: "identifier", runtime: "string" },
+  regtype: { family: "identifier", runtime: "string" },
+  regproc: { family: "identifier", runtime: "string" },
+  regprocedure: { family: "identifier", runtime: "string" },
+  regoper: { family: "identifier", runtime: "string" },
+  regoperator: { family: "identifier", runtime: "string" },
+  regconfig: { family: "identifier", runtime: "string" },
+  regdictionary: { family: "identifier", runtime: "string" },
+  pg_lsn: { family: "identifier", runtime: "string" },
+  txid_snapshot: { family: "identifier", runtime: "string" },
+  inet: { family: "network", runtime: "string" },
+  cidr: { family: "network", runtime: "string" },
+  macaddr: { family: "network", runtime: "string" },
+  macaddr8: { family: "network", runtime: "string" },
+  point: { family: "spatial", runtime: "unknown" },
+  line: { family: "spatial", runtime: "unknown" },
+  lseg: { family: "spatial", runtime: "unknown" },
+  box: { family: "spatial", runtime: "unknown" },
+  path: { family: "spatial", runtime: "unknown" },
+  polygon: { family: "spatial", runtime: "unknown" },
+  circle: { family: "spatial", runtime: "unknown" },
+  tsvector: { family: "textsearch", runtime: "string" },
+  tsquery: { family: "textsearch", runtime: "string" },
+  int4range: { family: "range", runtime: "unknown" },
+  int8range: { family: "range", runtime: "unknown" },
+  numrange: { family: "range", runtime: "unknown" },
+  tsrange: { family: "range", runtime: "unknown" },
+  tstzrange: { family: "range", runtime: "unknown" },
+  daterange: { family: "range", runtime: "unknown" },
+  int4multirange: { family: "multirange", runtime: "unknown" },
+  int8multirange: { family: "multirange", runtime: "unknown" },
+  nummultirange: { family: "multirange", runtime: "unknown" },
+  tsmultirange: { family: "multirange", runtime: "unknown" },
+  tstzmultirange: { family: "multirange", runtime: "unknown" },
+  datemultirange: { family: "multirange", runtime: "unknown" }
+};
+var postgresSpecificDatatypeKeys = [
+  "int2",
+  "int4",
+  "int8",
+  "float4",
+  "float8",
+  "money",
+  "bool",
+  "timetz",
+  "timestamptz",
+  "interval",
+  "bytea",
+  "citext",
+  "name",
+  "jsonb",
+  "xml",
+  "bit",
+  "varbit",
+  "oid",
+  "xid",
+  "xid8",
+  "cid",
+  "tid",
+  "regclass",
+  "regtype",
+  "regproc",
+  "regprocedure",
+  "regoper",
+  "regoperator",
+  "regconfig",
+  "regdictionary",
+  "pg_lsn",
+  "txid_snapshot",
+  "inet",
+  "cidr",
+  "macaddr",
+  "macaddr8",
+  "point",
+  "line",
+  "lseg",
+  "box",
+  "path",
+  "polygon",
+  "circle",
+  "tsvector",
+  "tsquery",
+  "int4range",
+  "int8range",
+  "numrange",
+  "tsrange",
+  "tstzrange",
+  "daterange",
+  "int4multirange",
+  "int8multirange",
+  "nummultirange",
+  "tsmultirange",
+  "tstzmultirange",
+  "datemultirange"
+];
+var mysqlDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "date",
+      "time",
+      "datetime",
+      "timestamp",
+      "year",
+      "binary",
+      "json",
+      "bit",
+      "enum",
+      "set",
+      "null"
+    ],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "text", "boolean", "date", "time", "datetime", "timestamp", "year", "bit"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "text", "numeric"],
+    traits: {}
+  },
+  bit: {
+    compareGroup: "bit",
+    castTargets: ["bit", "text", "numeric"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "datetime", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "datetime", "timestamp", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  datetime: {
+    compareGroup: "datetime",
+    castTargets: ["datetime", "timestamp", "date", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  timestamp: {
+    compareGroup: "timestamp",
+    castTargets: ["timestamp", "datetime", "date", "text"],
+    traits: {
+      ordered: true
+    }
+  },
+  year: {
+    compareGroup: "year",
+    castTargets: ["year", "text", "numeric"],
+    traits: {
+      ordered: true
+    }
+  },
+  binary: {
+    compareGroup: "binary",
+    castTargets: ["binary", "text"],
+    traits: {}
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  spatial: {
+    compareGroup: "spatial",
+    castTargets: ["spatial", "text"],
+    traits: {}
+  },
+  enum: {
+    compareGroup: "enum",
+    castTargets: ["enum", "text"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  set: {
+    compareGroup: "set",
+    castTargets: ["set", "text"],
+    traits: {
+      textual: true
+    }
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: [
+      "text",
+      "numeric",
+      "boolean",
+      "bit",
+      "date",
+      "time",
+      "datetime",
+      "timestamp",
+      "year",
+      "binary",
+      "json",
+      "spatial",
+      "enum",
+      "set",
+      "null"
+    ],
+    traits: {}
+  }
+};
+var mysqlDatatypeKinds = {
+  char: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  tinytext: { family: "text", runtime: "string" },
+  text: { family: "text", runtime: "string" },
+  mediumtext: { family: "text", runtime: "string" },
+  longtext: { family: "text", runtime: "string" },
+  tinyint: { family: "numeric", runtime: "number" },
+  smallint: { family: "numeric", runtime: "number" },
+  mediumint: { family: "numeric", runtime: "number" },
+  int: { family: "numeric", runtime: "number" },
+  integer: { family: "numeric", runtime: "number" },
+  bigint: { family: "numeric", runtime: "bigintString" },
+  decimal: { family: "numeric", runtime: "decimalString" },
+  dec: { family: "numeric", runtime: "decimalString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  fixed: { family: "numeric", runtime: "decimalString" },
+  float: { family: "numeric", runtime: "number" },
+  double: { family: "numeric", runtime: "number" },
+  real: { family: "numeric", runtime: "number" },
+  bool: { family: "boolean", runtime: "boolean" },
+  boolean: { family: "boolean", runtime: "boolean" },
+  bit: { family: "bit", runtime: "string" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  datetime: { family: "datetime", runtime: "localDateTime" },
+  timestamp: { family: "timestamp", runtime: "localDateTime" },
+  year: { family: "year", runtime: "year" },
+  binary: { family: "binary", runtime: "bytes" },
+  varbinary: { family: "binary", runtime: "bytes" },
+  tinyblob: { family: "binary", runtime: "bytes" },
+  blob: { family: "binary", runtime: "bytes" },
+  mediumblob: { family: "binary", runtime: "bytes" },
+  longblob: { family: "binary", runtime: "bytes" },
+  json: { family: "json", runtime: "json" },
+  geometry: { family: "spatial", runtime: "unknown" },
+  point: { family: "spatial", runtime: "unknown" },
+  linestring: { family: "spatial", runtime: "unknown" },
+  polygon: { family: "spatial", runtime: "unknown" },
+  multipoint: { family: "spatial", runtime: "unknown" },
+  multilinestring: { family: "spatial", runtime: "unknown" },
+  multipolygon: { family: "spatial", runtime: "unknown" },
+  geometrycollection: { family: "spatial", runtime: "unknown" },
+  enum: { family: "enum", runtime: "string" },
+  set: { family: "set", runtime: "string" }
+};
+var mysqlSpecificDatatypeKeys = [
+  "tinytext",
+  "mediumtext",
+  "longtext",
+  "tinyint",
+  "smallint",
+  "mediumint",
+  "dec",
+  "fixed",
+  "float",
+  "double",
+  "bool",
+  "bit",
+  "year",
+  "binary",
+  "varbinary",
+  "tinyblob",
+  "mediumblob",
+  "longblob",
+  "geometry",
+  "point",
+  "linestring",
+  "polygon",
+  "multipoint",
+  "multilinestring",
+  "multipolygon",
+  "geometrycollection"
+];
+var sqliteDatatypeFamilies = {
+  text: {
+    compareGroup: "text",
+    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {
+      textual: true,
+      ordered: true
+    }
+  },
+  numeric: {
+    compareGroup: "numeric",
+    castTargets: ["numeric", "integer", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  integer: {
+    compareGroup: "numeric",
+    castTargets: ["integer", "numeric", "real", "text", "boolean", "date", "time", "datetime"],
+    traits: {
+      ordered: true
+    }
+  },
+  real: {
+    compareGroup: "numeric",
+    castTargets: ["real", "numeric", "integer", "text", "boolean"],
+    traits: {
+      ordered: true
+    }
+  },
+  boolean: {
+    compareGroup: "boolean",
+    castTargets: ["boolean", "integer", "numeric", "text"],
+    traits: {}
+  },
+  date: {
+    compareGroup: "date",
+    castTargets: ["date", "time", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  time: {
+    compareGroup: "time",
+    castTargets: ["time", "date", "datetime", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  datetime: {
+    compareGroup: "datetime",
+    castTargets: ["datetime", "date", "time", "text", "numeric", "integer"],
+    traits: {
+      ordered: true
+    }
+  },
+  json: {
+    compareGroup: "json",
+    castTargets: ["json", "text"],
+    traits: {}
+  },
+  blob: {
+    compareGroup: "blob",
+    castTargets: ["blob", "text"],
+    traits: {}
+  },
+  null: {
+    compareGroup: "null",
+    castTargets: ["text", "numeric", "integer", "real", "boolean", "date", "time", "datetime", "json", "blob", "null"],
+    traits: {}
+  }
+};
+var sqliteDatatypeKinds = {
+  text: { family: "text", runtime: "string" },
+  varchar: { family: "text", runtime: "string" },
+  char: { family: "text", runtime: "string" },
+  clob: { family: "text", runtime: "string" },
+  int: { family: "integer", runtime: "number" },
+  integer: { family: "integer", runtime: "number" },
+  bigint: { family: "integer", runtime: "bigintString" },
+  numeric: { family: "numeric", runtime: "decimalString" },
+  decimal: { family: "numeric", runtime: "decimalString" },
+  real: { family: "real", runtime: "number" },
+  double: { family: "real", runtime: "number" },
+  boolean: { family: "boolean", runtime: "boolean" },
+  date: { family: "date", runtime: "localDate" },
+  time: { family: "time", runtime: "localTime" },
+  datetime: { family: "datetime", runtime: "localDateTime" },
+  timestamp: { family: "datetime", runtime: "localDateTime" },
+  json: { family: "json", runtime: "json" },
+  blob: { family: "blob", runtime: "bytes" }
+};
+var sqliteSpecificDatatypeKeys = [
+  "clob",
+  "double"
+];
+var pickDatatypeConstructors = (module, keys) => Object.fromEntries(keys.map((key2) => [key2, module[key2]]));
 
 // src/internal/dsl-plan-runtime.ts
 var renderSelectLockMode = (mode) => mode === "update" ? "for update" : "for share";
@@ -2491,7 +3557,7 @@ 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 brandString = (pattern, brand4) => Schema3.String.pipe(Schema3.check(Schema3.isPattern(pattern)), Schema3.brand(brand4));
 var localDatePattern = /^(\d{4})-(\d{2})-(\d{2})$/;
 var isValidLocalDateString = (value) => {
   const match = localDatePattern.exec(value);
@@ -2544,11 +3610,11 @@ 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 LocalDateStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localDatePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalDateString(value))), Schema3.brand("LocalDateString"));
+var LocalTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalTimeString(value))), Schema3.brand("LocalTimeString"));
+var OffsetTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(offsetTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidOffsetTimeString(value))), Schema3.brand("OffsetTimeString"));
+var LocalDateTimeStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(localDateTimePattern)), Schema3.check(Schema3.makeFilter((value) => isValidLocalDateTimeString(value))), Schema3.brand("LocalDateTimeString"));
+var InstantStringSchema = Schema3.String.pipe(Schema3.check(Schema3.isPattern(instantPattern)), Schema3.check(Schema3.makeFilter((value) => isValidInstantString(value))), Schema3.brand("InstantString"));
 var YearStringSchema = brandString(/^\d{4}$/, "YearString");
 var canonicalizeBigIntString = (input) => {
   const trimmed = input.trim();
@@ -2588,13 +3654,22 @@ var isCanonicalDecimalString = (value) => {
     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);
+var BigIntStringSchema = Schema3.String.pipe(Schema3.check(Schema3.makeFilter((value) => isCanonicalBigIntString(value))), Schema3.brand("BigIntString"));
+var DecimalStringSchema = Schema3.String.pipe(Schema3.check(Schema3.makeFilter((value) => isCanonicalDecimalString(value))), Schema3.brand("DecimalString"));
+var JsonValueSchema = Schema3.suspend(() => Schema3.Union([
+  Schema3.String,
+  Schema3.Number.check(Schema3.isFinite()),
+  Schema3.Boolean,
+  Schema3.Null,
+  Schema3.Array(JsonValueSchema),
+  Schema3.Record(Schema3.String, JsonValueSchema)
+]));
+var JsonPrimitiveSchema = Schema3.Union([
+  Schema3.String,
+  Schema3.Number.check(Schema3.isFinite()),
+  Schema3.Boolean,
+  Schema3.Null
+]);
 
 // src/internal/runtime/normalize.ts
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -3079,7 +4154,7 @@ 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 isExpression2 = (value) => typeof value === "object" && value !== null && (TypeId2 in value);
 var projectionAliasOf = (expression) => (TypeId9 in expression) ? expression[TypeId9].alias : undefined;
 var pathKeyOf = (path2) => JSON.stringify(path2);
 var formatProjectionPath = (path2) => path2.join(".");
@@ -3088,7 +4163,7 @@ var flattenSelection = (selection, path2 = []) => {
   const fields = [];
   for (const [key2, value] of Object.entries(selection)) {
     const nextPath = [...path2, key2];
-    if (isExpression(value)) {
+    if (isExpression2(value)) {
       fields.push({
         path: nextPath,
         expression: value,
@@ -3158,8 +4233,8 @@ 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 isExpression3 = (value) => value !== null && typeof value === "object" && (TypeId2 in value);
+var expressionGroupingKey = (value) => isExpression3(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(",");
@@ -3215,7 +4290,7 @@ var jsonPathGroupingKey = (segments) => {
   }
   return segments.map(jsonSegmentGroupingKey).join(",");
 };
-var isJsonPath = (value) => value !== null && typeof value === "object" && (TypeId8 in value);
+var isJsonPath = (value) => value !== null && typeof value === "object" && (TypeId4 in value);
 var jsonOpaquePathGroupingKey = (value) => {
   if (isJsonPath(value)) {
     return `jsonpath:${jsonPathGroupingKey(value.segments)}`;
@@ -3223,7 +4298,7 @@ var jsonOpaquePathGroupingKey = (value) => {
   if (typeof value === "string") {
     return `jsonpath:${escapeGroupingText(value)}`;
   }
-  if (isExpression2(value)) {
+  if (isExpression3(value)) {
     return `jsonpath:${groupingKeyOfExpression(value)}`;
   }
   return "jsonpath:unknown";
@@ -3354,14 +4429,15 @@ var dedupeGroupedExpressions = (values) => {
 
 // src/internal/dialect-renderers/postgres.ts
 var renderDbType = (dialect, dbType) => {
-  if (dialect.name === "postgres" && dbType.kind === "blob") {
-    return "bytea";
-  }
-  return renderDbTypeName(dbType.kind);
+  return renderDbTypeName(renderPortableDatatypeDdlType(dialect.name, dbType.kind) ?? dbType.kind);
 };
 var isArrayDbType = (dbType) => ("element" in dbType);
 var renderCastType = (dialect, dbType) => {
   const kind = dbType?.kind;
+  const portableType = renderPortableDatatypeCastType(dialect.name, kind);
+  if (portableType !== undefined) {
+    return renderDbTypeName(portableType);
+  }
   if (dialect.name !== "mysql") {
     return renderDbTypeName(kind);
   }
@@ -3383,13 +4459,13 @@ var renderCastType = (dialect, dbType) => {
       return renderDbTypeName(kind);
   }
 };
-var casingForTable = (table, state) => merge(state.casing, table[TypeId6].casing);
+var casingForTable = (table, state) => merge(state.casing, table[TypeId7].casing);
 var casedTableName = (table, state) => {
-  const tableState = table[TypeId6];
+  const tableState = table[TypeId7];
   return applyCategory(casingForTable(table, state), "tables", tableState.baseName);
 };
 var casedSchemaName = (table, state) => {
-  const schemaName = table[TypeId6].schemaName;
+  const schemaName = table[TypeId7].schemaName;
   return schemaName === undefined ? undefined : applyCategory(casingForTable(table, state), "schemas", schemaName);
 };
 var casedColumnName = (columnName, state, tableName) => {
@@ -3403,7 +4479,7 @@ var casedColumnName = (columnName, state, tableName) => {
 };
 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 stateWithTableCasing = (state, source) => typeof source === "object" && source !== null && (TypeId7 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);
@@ -3416,9 +4492,9 @@ var registerSourceReference = (source, tableName, state) => {
   if (typeof source !== "object" || source === null) {
     return;
   }
-  if (TypeId6 in source) {
+  if (TypeId7 in source) {
     const table = source;
-    const tableState = table[TypeId6];
+    const tableState = table[TypeId7];
     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) => [
@@ -3532,11 +4608,11 @@ var renderCreateTableSql = (targetSource, state, dialect, ifNotExists) => {
   }
   const table = targetSource.source;
   const tableCasing = casingForTable(table, state);
-  const fields = table[TypeId6].fields;
+  const fields = table[TypeId7].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);
+  validateOptions(table[TypeId7].name, fields, tableOptions);
   for (const option2 of tableOptions) {
     if (typeof option2 !== "object" || option2 === null || !("kind" in option2)) {
       continue;
@@ -3595,8 +4671,8 @@ var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
     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 table2 = typeof targetSource.source === "object" && targetSource.source !== null && TypeId7 in targetSource.source ? targetSource.source : undefined;
+    const schemaName = table2?.[TypeId7].schemaName;
     const tableCasing2 = table2 === undefined ? state.casing : casingForTable(table2, state);
     const renderedSchemaName = table2 === undefined ? schemaName : casedSchemaName(table2, state);
     const renderedIndexName = applyCategory(tableCasing2, "indexes", name);
@@ -3607,7 +4683,7 @@ var renderDropIndexSql = (targetSource, ddl, state, dialect) => {
   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 isExpression3 = (value) => value !== null && typeof value === "object" && (TypeId2 in value);
+var isExpression4 = (value) => value !== null && typeof value === "object" && (TypeId2 in value);
 var isJsonDbType2 = (dbType) => {
   if (dbType.kind === "jsonb" || dbType.kind === "json") {
     return true;
@@ -3618,7 +4694,7 @@ var isJsonDbType2 = (dbType) => {
   const variant = dbType.variant;
   return variant === "json" || variant === "jsonb";
 };
-var isJsonExpression = (value) => isExpression3(value) && isJsonDbType2(value[TypeId2].dbType);
+var isJsonExpression2 = (value) => isExpression4(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) => {
@@ -3665,7 +4741,7 @@ 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" && (TypeId8 in value);
+var isJsonPathValue = (value) => value !== null && typeof value === "object" && (TypeId4 in value);
 var isOptionalJsonPathNumber = (value) => value === undefined || typeof value === "number" && Number.isFinite(value);
 var isJsonPathSegment = (segment) => {
   if (typeof segment === "string") {
@@ -3722,7 +4798,7 @@ var extractJsonPathSegments = (node) => {
       return [key(segment)];
     }
     if (typeof segment === "number") {
-      return [index2(segment)];
+      return [index(segment)];
     }
     if (segment !== null && typeof segment === "object" && SegmentTypeId in segment) {
       return [segment];
@@ -3795,7 +4871,7 @@ var renderPostgresJsonAccessStep = (segment, textMode, state, dialect) => {
   }
 };
 var renderPostgresJsonValue = (value, state, dialect) => {
-  if (!isExpression3(value)) {
+  if (!isExpression4(value)) {
     throw new Error("Expected a JSON expression");
   }
   const rendered = renderExpression2(value, state, dialect);
@@ -3839,7 +4915,7 @@ var renderJsonOpaquePath = (value, state, dialect) => {
     }
     return dialect.renderLiteral(value, state);
   }
-  if (isExpression3(value)) {
+  if (isExpression4(value)) {
     const ast = value[TypeId3];
     if (ast.kind === "literal" && typeof ast.value === "string" && ast.value.trim().length === 0) {
       throw new Error("SQL/JSON path input must be a non-empty string");
@@ -3889,8 +4965,8 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
   const base = extractJsonBase(ast);
   const segments = extractJsonPathSegments(ast);
   const exact = segments.every((segment) => segment.kind === "key" || segment.kind === "index");
-  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression(expression) ? renderPostgresJsonKind(expression) : undefined;
-  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression(base) ? renderPostgresJsonKind(base) : undefined;
+  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression2(expression) ? renderPostgresJsonKind(expression) : undefined;
+  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression2(base) ? renderPostgresJsonKind(base) : undefined;
   switch (kind) {
     case "jsonGet":
     case "jsonPath":
@@ -3900,7 +4976,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonPathText":
     case "jsonAccessText":
     case "jsonTraverseText": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       const baseSql = renderExpression2(base, state, dialect);
@@ -3923,7 +4999,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonKeyExists":
     case "jsonHasAnyKeys":
     case "jsonHasAllKeys": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       const baseSql = dialect.name === "postgres" ? renderPostgresJsonValue(base, state, dialect) : renderExpression2(base, state, dialect);
@@ -3953,7 +5029,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonConcat":
     case "jsonMerge": {
-      if (!isExpression3(ast.left) || !isExpression3(ast.right)) {
+      if (!isExpression4(ast.left) || !isExpression4(ast.right)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -3990,7 +5066,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonToJson":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -4001,7 +5077,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonToJsonb":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -4012,7 +5088,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonTypeOf":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -4024,7 +5100,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonLength":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -4039,7 +5115,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonKeys":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -4053,7 +5129,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       }
       return;
     case "jsonStripNulls":
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -4064,7 +5140,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     case "jsonDelete":
     case "jsonDeletePath":
     case "jsonRemove": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       if (dialect.name === "postgres") {
@@ -4082,11 +5158,11 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonSet":
     case "jsonInsert": {
-      if (!isExpression3(base) || segments.length === 0) {
+      if (!isExpression4(base) || segments.length === 0) {
         return;
       }
       const nextValue = extractJsonValue(ast);
-      if (!isExpression3(nextValue)) {
+      if (!isExpression4(nextValue)) {
         return;
       }
       const createMissing = ast.createMissing === true;
@@ -4103,7 +5179,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonPathExists": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -4119,7 +5195,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       return;
     }
     case "jsonPathMatch": {
-      if (!isExpression3(base)) {
+      if (!isExpression4(base)) {
         return;
       }
       const path2 = ast.path ?? ast.query ?? ast.right;
@@ -4313,12 +5389,12 @@ var renderQueryAst2 = (ast, state, dialect, options2 = {}) => {
         const columns = insertSource.columns.map((column) => quoteColumn(column, state, dialect, targetSource.tableName)).join(", ");
         if (dialect.name === "postgres") {
           const table = targetSource.source;
-          const fields = table[TypeId6].fields;
+          const fields = table[TypeId7].fields;
           const rendered = insertSource.values.map((entry) => `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName], state, dialect), state)} as ${renderCastType(dialect, fields[entry.columnName].metadata.dbType)}[])`).join(", ");
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
           const rowCount = insertSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index3) => `(${insertSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId6].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
+          const rows = Array.from({ length: rowCount }, (_, index3) => `(${insertSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId7].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -4606,11 +5682,11 @@ var renderSourceReference = (source, tableName, baseTableName, state, dialect) =
     const columnNames = Object.keys(tableFunction.columns);
     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 schemaName = typeof source === "object" && source !== null && TypeId7 in source ? casedSchemaName(source, state) : undefined;
+  if (typeof source === "object" && source !== null && TypeId7 in source) {
     const table = source;
     const renderedBaseName = casedTableName(table, state);
-    const renderedTableName = table[TypeId6].kind === "alias" ? tableName : renderedBaseName;
+    const renderedTableName = table[TypeId7].kind === "alias" ? tableName : renderedBaseName;
     return dialect.renderTableReference(renderedTableName, renderedBaseName, schemaName);
   }
   return dialect.renderTableReference(applyCategory(state.casing, "tables", tableName), applyCategory(state.casing, "tables", baseTableName), schemaName);
@@ -4717,11 +5793,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions("contains", ast.left, ast.right);
       if (dialect.name === "postgres") {
         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);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} @> ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
         return `json_contains(${renderExpression2(leftExpression, state, dialect)}, ${renderExpression2(rightExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -4730,11 +5806,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions("containedBy", ast.left, ast.right);
       if (dialect.name === "postgres") {
         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);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} <@ ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
         return `json_contains(${renderExpression2(rightExpression, state, dialect)}, ${renderExpression2(leftExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -4743,11 +5819,11 @@ var renderExpression2 = (expression, state, dialect) => {
       const [leftExpression, rightExpression] = expectBinaryExpressions("overlaps", ast.left, ast.right);
       if (dialect.name === "postgres") {
         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);
+        const left = isJsonExpression2(leftExpression) ? renderPostgresJsonValue(leftExpression, state, dialect) : renderExpression2(leftExpression, state, dialect);
+        const right = isJsonExpression2(rightExpression) ? renderPostgresJsonValue(rightExpression, state, dialect) : renderExpression2(rightExpression, state, dialect);
         return `(${left} && ${right})`;
       }
-      if (dialect.name === "mysql" && isJsonExpression(leftExpression) && isJsonExpression(rightExpression)) {
+      if (dialect.name === "mysql" && isJsonExpression2(leftExpression) && isJsonExpression2(rightExpression)) {
         return `json_overlaps(${renderExpression2(leftExpression, state, dialect)}, ${renderExpression2(rightExpression, state, dialect)})`;
       }
       throw new Error("Unsupported container operator for SQL rendering");
@@ -4979,7 +6055,7 @@ var normalizeDdlExpressionSql = (expression, state) => {
 
 // src/postgres/schema-management.ts
 import * as Schema6 from "effect/Schema";
-import { pipeArguments as pipeArguments5 } from "effect/Pipeable";
+import { pipeArguments as pipeArguments6 } 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_$]*$/;
@@ -4988,7 +6064,7 @@ var renderIdentifier = (value) => safeUnquotedIdentifier.test(value) ? value : q
 var renderQualifiedTypeName = (name, schemaName) => schemaName === undefined || schemaName === "public" ? renderIdentifier(name) : `${renderIdentifier(schemaName)}.${renderIdentifier(name)}`;
 var EnumProto = {
   pipe() {
-    return pipeArguments5(this, arguments);
+    return pipeArguments6(this, arguments);
   },
   qualifiedName() {
     return this.schemaName === undefined || this.schemaName === "public" ? this.name : `${this.schemaName}.${this.name}`;
@@ -5001,12 +6077,7 @@ var EnumProto = {
     };
   },
   column() {
-    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), {
+    return makeColumnDefinition(Schema6.Literals(this.values), {
       dbType: this.type(),
       nullable: false,
       hasDefault: false,
@@ -5026,7 +6097,7 @@ var EnumProto = {
 };
 var SequenceProto = {
   pipe() {
-    return pipeArguments5(this, arguments);
+    return pipeArguments6(this, arguments);
   },
   qualifiedName() {
     return this.schemaName === undefined || this.schemaName === "public" ? this.name : `${this.schemaName}.${this.name}`;
@@ -5059,7 +6130,7 @@ 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") && (TypeId6 in value);
+var isTableDefinition = (value) => value !== null && (typeof value === "object" || typeof value === "function") && (TypeId7 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 : [
@@ -5081,7 +6152,7 @@ function mapOptionName(name, casing, category) {
 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));
+var isDdlExpressionLike = (value) => typeof value === "object" && value !== null && ((TypeId2 in value) || (TypeId5 in value));
 function mapIndexKey(key2, casing, expressionState) {
   if (typeof key2 !== "object" || key2 === null || !("kind" in key2)) {
     return key2;
@@ -5103,7 +6174,7 @@ function mapIndexKey(key2, casing, expressionState) {
   }
   return key2;
 }
-var mapOption = (option2, casing, expressionState) => {
+var mapOption2 = (option2, casing, expressionState) => {
   switch (option2.kind) {
     case "index":
       return {
@@ -5160,7 +6231,7 @@ var mapOption = (option2, casing, expressionState) => {
   }
 };
 var toTableModel = (table) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   const casing = state.casing;
   const tableName = applyCasing(casing, "tables", state.baseName);
   const schemaName = state.schemaName === undefined ? undefined : applyCasing(casing, "schemas", state.schemaName);
@@ -5194,7 +6265,7 @@ var toTableModel = (table) => {
     schemaName,
     name: tableName,
     columns,
-    options: normalizedOptions.map((option2) => typeof option2 === "object" && option2 !== null && ("kind" in option2) ? mapOption(option2, casing, expressionState) : option2),
+    options: normalizedOptions.map((option2) => typeof option2 === "object" && option2 !== null && ("kind" in option2) ? mapOption2(option2, casing, expressionState) : option2),
     table
   };
 };
@@ -5205,7 +6276,7 @@ var toEnumModel = (definition) => ({
   values: [...definition.values]
 });
 var enumModelsOfTable = (table) => {
-  const state = table[TypeId6];
+  const state = table[TypeId7];
   const fields = state.fields;
   return Object.values(fields).flatMap((column) => column.metadata.enum === undefined ? [] : [
     {