effect-qb 0.14.0 → 0.16.0

package/dist/postgres/metadata.js

@@ -27,9 +27,9 @@ __export(exports_metadata, {
 // src/internal/table.ts
 import { pipeArguments as pipeArguments2 } from "effect/Pipeable";
 
-// src/internal/plan.ts
-var exports_plan = {};
-__export(exports_plan, {
+// src/internal/row-set.ts
+var exports_row_set = {};
+__export(exports_row_set, {
   TypeId: () => TypeId
 });
 var TypeId = Symbol.for("effect-qb/Plan");
@@ -38,9 +38,9 @@ var TypeId = Symbol.for("effect-qb/Plan");
 import { pipeArguments } from "effect/Pipeable";
 import * as Schema from "effect/Schema";
 
-// src/internal/expression.ts
-var exports_expression = {};
-__export(exports_expression, {
+// src/internal/scalar.ts
+var exports_scalar = {};
+__export(exports_scalar, {
   TypeId: () => TypeId2
 });
 var TypeId2 = Symbol.for("effect-qb/Expression");
@@ -56,19 +56,28 @@ var ColumnProto = {
     return pipeArguments(this, arguments);
   }
 };
+var attachPipe = (value) => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments(value, arguments);
+    }
+  });
+  return value;
+};
 var makeColumnDefinition = (schema, metadata) => {
-  const column = Object.create(ColumnProto);
+  const column = attachPipe(Object.create(ColumnProto));
   column.schema = schema;
   column.metadata = metadata;
   column[TypeId2] = {
     runtime: undefined,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect,
-    aggregation: "scalar",
-    source: undefined,
-    sourceNullability: "propagate",
+    kind: "scalar",
     dependencies: {}
   };
   column[ColumnTypeId] = {
@@ -85,17 +94,16 @@ var makeColumnDefinition = (schema, metadata) => {
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
-    enum: metadata.enum,
-    source: undefined,
-    dependencies: {}
+    enum: metadata.enum
   };
   return column;
 };
 var remapColumnDefinition = (column, options = {}) => {
   const schema = options.schema ?? column.schema;
   const metadata = options.metadata ?? column.metadata;
-  const next = Object.create(ColumnProto);
+  const next = attachPipe(Object.create(ColumnProto));
   next.schema = schema;
   next.metadata = metadata;
   next[TypeId2] = {
@@ -103,6 +111,7 @@ var remapColumnDefinition = (column, options = {}) => {
     runtime: undefined,
     dbType: metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: metadata.driverValueMapping,
     nullability: metadata.nullable ? "maybe" : "never",
     dialect: metadata.dbType.dialect
   };
@@ -121,6 +130,7 @@ var remapColumnDefinition = (column, options = {}) => {
     defaultValue: metadata.defaultValue,
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
+    driverValueMapping: metadata.driverValueMapping,
     identity: metadata.identity,
     enum: metadata.enum
   };
@@ -135,22 +145,17 @@ var remapColumnDefinition = (column, options = {}) => {
 var bindColumn = (tableName, columnName, column, baseTableName, schemaName) => {
   const brandName = `${tableName}.${columnName}`;
   const schema = column.metadata.brand === true ? Schema.brand(brandName)(column.schema) : column.schema;
-  const bound = Object.create(ColumnProto);
+  const bound = attachPipe(Object.create(ColumnProto));
   bound.schema = schema;
   bound.metadata = column.metadata;
   bound[TypeId2] = {
     runtime: undefined,
     dbType: column.metadata.dbType,
     runtimeSchema: schema,
+    driverValueMapping: column.metadata.driverValueMapping,
     nullability: column.metadata.nullable ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
-    aggregation: "scalar",
-    source: {
-      tableName,
-      columnName,
-      baseTableName
-    },
-    sourceNullability: "propagate",
+    kind: "scalar",
     dependencies: {
       [tableName]: true
     }
@@ -225,7 +230,9 @@ var collectInlineOptions = (fields) => {
           kind: "column",
           column: columnName,
           order: column.metadata.index.order,
-          nulls: column.metadata.index.nulls
+          nulls: column.metadata.index.nulls,
+          operatorClass: column.metadata.index.operatorClass,
+          collation: column.metadata.index.collation
         }],
         name: column.metadata.index.name,
         method: column.metadata.index.method,
@@ -379,6 +386,16 @@ var TableProto = {
     return pipeArguments2(this, arguments);
   }
 };
+var attachPipe2 = (value) => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments2(value, arguments);
+    }
+  });
+  return value;
+};
 var buildArtifacts = (name, fields, declaredOptions, schemaName) => {
   const normalizedOptions = [...collectInlineOptions(fields), ...declaredOptions];
   validateFieldDialects(name, fields);
@@ -397,7 +414,7 @@ var makeTable = (name, fields, declaredOptions, baseName = name, kind = "schema"
   const resolvedSchemaName = schemaMode === "explicit" ? schemaName : "public";
   const artifacts = buildArtifacts(name, fields, declaredOptions, resolvedSchemaName);
   const dialect = resolveFieldDialect(fields);
-  const table = Object.create(TableProto);
+  const table = attachPipe2(Object.create(TableProto));
   table.name = name;
   table.columns = artifacts.columns;
   table.schemas = artifacts.schemas;
@@ -448,7 +465,7 @@ var validateClassOptions = (declaredOptions) => {
 var resolveFieldDialect = (fields) => {
   const dialects = [...new Set(Object.values(fields).map((field) => field.metadata.dbType.dialect))];
   if (dialects.length === 0) {
-    return "postgres";
+    throw new Error("Cannot infer table dialect from an empty field set");
   }
   if (dialects.length > 1) {
     throw new Error(`Mixed table dialects are not supported: ${dialects.join(", ")}`);
@@ -507,7 +524,7 @@ var schema = (schemaName) => ({
 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 = Object.create(TableProto);
+  const aliased = attachPipe2(Object.create(TableProto));
   aliased.name = aliasName;
   aliased.columns = columns;
   aliased.schemas = deriveSchemas(aliasName, state.fields, state.primaryKey);
@@ -627,31 +644,6 @@ var check = (name, predicate) => makeOption({
   predicate
 });
 
-// src/internal/postgres-dialect.ts
-var quoteIdentifier = (value) => `"${value.replaceAll('"', '""')}"`;
-var renderLiteral = (value, state) => {
-  if (value === null) {
-    return "null";
-  }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false";
-  }
-  state.params.push(value);
-  return `$${state.params.length}`;
-};
-var postgresDialect = {
-  name: "postgres",
-  quoteIdentifier,
-  renderLiteral,
-  renderTableReference(tableName, baseTableName, schemaName) {
-    const renderedBase = schemaName ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}` : quoteIdentifier(baseTableName);
-    return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier(tableName)}`;
-  },
-  renderConcat(values) {
-    return `(${values.join(" || ")})`;
-  }
-};
-
 // src/internal/schema-expression.ts
 import { parse, toSql } from "pgsql-ast-parser";
 import { pipeArguments as pipeArguments3 } from "effect/Pipeable";
@@ -661,19 +653,48 @@ var SchemaExpressionProto = {
     return pipeArguments3(this, arguments);
   }
 };
+var attachPipe3 = (value) => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments3(value, arguments);
+    }
+  });
+  return value;
+};
 var isSchemaExpression = (value) => typeof value === "object" && value !== null && (TypeId5 in value);
 var fromAst = (ast) => {
-  const expression = Object.create(SchemaExpressionProto);
+  const expression = attachPipe3(Object.create(SchemaExpressionProto));
   expression[TypeId5] = {
-    dialect: "postgres",
     ast
   };
   return expression;
 };
+var fromSql = (sql) => {
+  const expression = attachPipe3(Object.create(SchemaExpressionProto));
+  expression[TypeId5] = {
+    sql: sql.trim()
+  };
+  return expression;
+};
 var parseExpression = (sql) => fromAst(parse(sql, "expr"));
-var toAst = (expression) => expression[TypeId5].ast;
-var render = (expression) => toSql.expr(expression[TypeId5].ast);
-var normalize = (expression) => parseExpression(render(expression));
+var toAst = (expression) => {
+  const ast = expression[TypeId5].ast;
+  if (ast !== undefined) {
+    return ast;
+  }
+  return parse(render(expression), "expr");
+};
+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);
+  }
+})();
 
 // src/internal/query.ts
 import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
@@ -681,7 +702,7 @@ import { pipeArguments as pipeArguments4 } from "effect/Pipeable";
 // src/internal/query-ast.ts
 var TypeId6 = Symbol.for("effect-qb/QueryAst");
 
-// src/internal/predicate-runtime.ts
+// src/internal/predicate/runtime.ts
 var trueFormula = () => ({ kind: "true" });
 var falseFormula = () => ({ kind: "false" });
 var atomFormula = (atom) => ({ kind: "atom", atom });
@@ -695,6 +716,7 @@ var emptyContext = () => ({
   nullKeys: new Set,
   eqLiterals: new Map,
   neqLiterals: new Map,
+  literalSets: new Map,
   sourceNames: new Set,
   contradiction: false,
   unknown: false
@@ -704,6 +726,7 @@ var cloneContext = (context) => ({
   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)])),
   sourceNames: new Set(context.sourceNames),
   contradiction: context.contradiction,
   unknown: context.unknown
@@ -737,7 +760,12 @@ var addEqLiteral = (context, key, value) => {
   if (neqValues?.has(value)) {
     context.contradiction = true;
   }
+  const existingSet = context.literalSets.get(key);
+  if (existingSet !== undefined && !existingSet.has(value)) {
+    context.contradiction = true;
+  }
   context.eqLiterals.set(key, value);
+  context.literalSets.set(key, new Set([value]));
 };
 var addNeqLiteral = (context, key, value) => {
   addNonNull(context, key);
@@ -748,6 +776,18 @@ var addNeqLiteral = (context, key, value) => {
   values.add(value);
   context.neqLiterals.set(key, values);
 };
+var addLiteralSet = (context, key, values) => {
+  addNonNull(context, key);
+  const existingEq = context.eqLiterals.get(key);
+  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) {
+    context.contradiction = true;
+  }
+};
 var applyEqColumn = (context, left, right) => {
   const leftValue = context.eqLiterals.get(left);
   const rightValue = context.eqLiterals.get(right);
@@ -787,6 +827,9 @@ var applyAtom = (context, atom) => {
     case "neq-literal":
       addNeqLiteral(context, atom.key, atom.value);
       return;
+    case "literal-set":
+      addLiteralSet(context, atom.key, new Set(atom.values));
+      return;
     case "eq-column":
       applyEqColumn(context, atom.left, atom.right);
       return;
@@ -809,6 +852,9 @@ var applyNegativeAtom = (context, atom) => {
     case "neq-literal":
       addEqLiteral(context, atom.key, atom.value);
       return;
+    case "literal-set":
+      addNonNull(context, atom.key);
+      return;
     case "eq-column":
       addNonNull(context, atom.left);
       addNonNull(context, atom.right);
@@ -841,6 +887,17 @@ var intersectNeqLiterals = (left, right) => {
   }
   return result;
 };
+var unionLiteralSets = (left, right) => {
+  const result = new Map;
+  for (const [key, leftValues] of left) {
+    const rightValues = right.get(key);
+    if (rightValues === undefined) {
+      continue;
+    }
+    result.set(key, new Set([...leftValues, ...rightValues]));
+  }
+  return result;
+};
 var intersectContexts = (left, right) => {
   if (left.contradiction) {
     return cloneContext(right);
@@ -853,6 +910,7 @@ var intersectContexts = (left, right) => {
     nullKeys: new Set(Array.from(left.nullKeys).filter((key) => right.nullKeys.has(key))),
     eqLiterals: intersectEqLiterals(left.eqLiterals, right.eqLiterals),
     neqLiterals: intersectNeqLiterals(left.neqLiterals, right.neqLiterals),
+    literalSets: unionLiteralSets(left.literalSets, right.literalSets),
     sourceNames: new Set(Array.from(left.sourceNames).filter((name) => right.sourceNames.has(name))),
     contradiction: false,
     unknown: left.unknown || right.unknown
@@ -926,6 +984,45 @@ var columnKeyOfExpression = (value) => {
   const ast = astOf(value);
   return ast.kind === "column" ? `${ast.tableName}.${ast.columnName}` : undefined;
 };
+var sameDbType = (left, right) => left.dialect === right.dialect && left.kind === right.kind;
+var jsonPathPredicateKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  switch (ast.kind) {
+    case "jsonGetText":
+    case "jsonPathText":
+    case "jsonAccessText":
+    case "jsonTraverseText": {
+      const jsonAst = ast;
+      const segments = jsonAst.segments;
+      if (segments.length === 0 || segments.length > 8) {
+        return;
+      }
+      const path = [];
+      for (const segment of segments) {
+        if (typeof segment !== "object" || segment === null || segment.kind !== "key") {
+          return;
+        }
+        path.push(segment.key);
+      }
+      if (path.length === 0) {
+        return;
+      }
+      const baseKey = columnKeyOfExpression(jsonAst.base);
+      return baseKey === undefined ? undefined : `${baseKey}#json:${path.join(".")}`;
+    }
+    default:
+      return;
+  }
+};
+var predicateKeyOfExpression = (value) => columnKeyOfExpression(value) ?? castPredicateKeyOfExpression(value) ?? jsonPathPredicateKeyOfExpression(value);
+var castPredicateKeyOfExpression = (value) => {
+  const ast = astOf(value);
+  if (ast.kind !== "cast") {
+    return;
+  }
+  const source = ast.value;
+  return sameDbType(source[TypeId2].dbType, ast.target) ? predicateKeyOfExpression(source) : undefined;
+};
 var valueKeyOfLiteral = (value) => {
   if (typeof value === "string") {
     return `string:${value}`;
@@ -945,7 +1042,7 @@ var valueKeyOfLiteral = (value) => {
   return "unknown";
 };
 var nonNullFactsOfExpression = (value) => {
-  const key = columnKeyOfExpression(value);
+  const key = predicateKeyOfExpression(value);
   return key === undefined ? undefined : atomFormula({ kind: "is-not-null", key });
 };
 var combineFacts = (left, right) => {
@@ -958,8 +1055,8 @@ var combineFacts = (left, right) => {
   return andFormula(left, right);
 };
 var formulaOfEq = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -1006,8 +1103,8 @@ var formulaOfEq = (left, right) => {
   });
 };
 var formulaOfNeq = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -1050,8 +1147,8 @@ var formulaOfNeq = (left, right) => {
   return combineFacts(nonNullFactsOfExpression(left), nonNullFactsOfExpression(right));
 };
 var formulaOfIsNotDistinctFrom = (left, right) => {
-  const leftKey = columnKeyOfExpression(left);
-  const rightKey = columnKeyOfExpression(right);
+  const leftKey = predicateKeyOfExpression(left);
+  const rightKey = predicateKeyOfExpression(right);
   const leftAst = astOf(left);
   const rightAst = astOf(right);
   const leftLiteral = leftAst.kind === "literal" ? leftAst.value : undefined;
@@ -1157,11 +1254,11 @@ var formulaOfExpression = (value) => {
       }
       return unknownTag("literal:non-boolean");
     case "isNull": {
-      const key = columnKeyOfExpression(ast.value);
+      const key = predicateKeyOfExpression(ast.value);
       return key === undefined ? unknownTag("isNull:unsupported") : atomFormula({ kind: "is-null", key });
     }
     case "isNotNull": {
-      const key = columnKeyOfExpression(ast.value);
+      const key = predicateKeyOfExpression(ast.value);
       return key === undefined ? unknownTag("isNotNull:unsupported") : atomFormula({ kind: "is-not-null", key });
     }
     case "not":
@@ -1180,11 +1277,19 @@ var formulaOfExpression = (value) => {
       return anyFormula(ast.values.map((value2) => formulaOfExpression(value2)));
     case "in": {
       const [left, ...rest] = ast.values;
-      return left === undefined ? falseFormula() : anyFormula(rest.map((value2) => formulaOfEq(left, value2)));
+      if (left === undefined) {
+        return falseFormula();
+      }
+      const key = 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)));
     }
     case "notIn": {
       const [left, ...rest] = ast.values;
-      return left === undefined ? trueFormula() : allFormula(rest.map((value2) => formulaOfNeq(left, value2)));
+      return left === undefined ? trueFormula() : combineFacts(nonNullFactsOfExpression(left), allFormula(rest.map((value2) => formulaOfNeq(left, value2))));
     }
     case "between":
       return combineFacts(ast.values.reduce((current, entry) => combineFacts(current, nonNullFactsOfExpression(entry)), undefined), unknownTag("variadic:between"));
@@ -1226,35 +1331,46 @@ var PlanProto = {
   }
 };
 var QueryTypeId = Symbol.for("effect-qb/Query/internal");
-var normalizeSources = (source) => source === undefined ? [] : Array.isArray(source) ? source : [source];
-var mergeSources = (left, right) => {
-  const values = [...normalizeSources(left), ...normalizeSources(right)];
-  if (values.length === 0) {
-    return;
-  }
-  if (values.length === 1) {
-    return values[0];
-  }
-  return values;
-};
-var mergeDependencies = (left, right = {}) => ({
-  ...left,
-  ...right
+var mergeDependencies = (left, right = undefined) => ({
+  ...left ?? {},
+  ...right ?? {}
 });
 var mergeAggregationRuntime = (left, right = "scalar") => left === "window" || right === "window" ? "window" : left === "aggregate" || right === "aggregate" ? "aggregate" : "scalar";
-var mergeAggregationManyRuntime = (values) => values.reduce((current, value) => mergeAggregationRuntime(current, value[TypeId2].aggregation), "scalar");
+var mergeAggregationManyRuntime = (values) => values.reduce((current, value) => mergeAggregationRuntime(current, value[TypeId2].kind), "scalar");
 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 mergeManySources = (values) => values.reduce((current, value) => mergeSources(current, value[TypeId2].source), undefined);
 var mergeManyDependencies = (values) => values.reduce((current, value) => mergeDependencies(current, value[TypeId2].dependencies), {});
 var makeExpression = (state, ast) => {
   const expression = Object.create(ExpressionProto);
-  expression[TypeId2] = state;
+  Object.defineProperty(expression, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments4(expression, arguments);
+    }
+  });
+  expression[TypeId2] = {
+    runtime: state.runtime,
+    dbType: state.dbType,
+    runtimeSchema: state.runtimeSchema,
+    driverValueMapping: state.driverValueMapping,
+    nullability: state.nullability,
+    dialect: state.dialect,
+    kind: state.kind ?? "scalar",
+    dependencies: state.dependencies ?? {}
+  };
   expression[TypeId3] = ast;
   return expression;
 };
-var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState) => {
+var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _insertState, _facts) => {
   const plan = Object.create(PlanProto);
+  Object.defineProperty(plan, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function() {
+      return pipeArguments4(plan, arguments);
+    }
+  });
   plan[TypeId] = state;
   plan[TypeId6] = ast;
   plan[QueryTypeId] = {
@@ -1262,6 +1378,7 @@ var makePlan = (state, ast, _assumptions, _capabilities, _statement, _target, _i
     availableNames: undefined,
     grouped: undefined,
     assumptions: _assumptions ?? trueFormula(),
+    facts: _facts ?? undefined,
     capabilities: undefined,
     statement: _statement ?? "select",
     target: _target ?? undefined,
@@ -1346,6 +1463,421 @@ var path = (...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;
+    }
+  }
+  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" && /^-?\d+$/.test(value.trim())) {
+    return BigInt(value.trim()).toString();
+  }
+  throw new Error("Expected an integer-like bigint value");
+};
+var canonicalizeDecimalString = (input) => {
+  const trimmed = input.trim();
+  const match = /^([+-]?)(\d+)(?:\.(\d+))?$/.exec(trimmed);
+  if (match === null) {
+    throw new Error("Expected a decimal string");
+  }
+  const sign = match[1] === "-" ? "-" : "";
+  const integer = match[2].replace(/^0+(?=\d)/, "") || "0";
+  const fraction = (match[3] ?? "").replace(/0+$/, "");
+  if (fraction.length === 0) {
+    return `${sign}${integer}`;
+  }
+  return `${sign}${integer}.${fraction}`;
+};
+var normalizeDecimalString = (value) => {
+  if (typeof value === "string") {
+    return canonicalizeDecimalString(value);
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const rendered = String(value);
+    if (/[eE]/.test(rendered)) {
+      throw new Error("Scientific notation is not a supported decimal runtime");
+    }
+    return canonicalizeDecimalString(rendered);
+  }
+  throw new Error("Expected a decimal-like value");
+};
+var normalizeLocalDate = (value) => {
+  if (value instanceof Date) {
+    return formatLocalDate(value);
+  }
+  const raw = expectString(value, "local date").trim();
+  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+    return raw;
+  }
+  const parsed = new Date(raw);
+  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);
+  }
+  const raw = expectString(value, "local time").trim();
+  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(raw)) {
+    return raw;
+  }
+  throw new Error("Expected a local-time value");
+};
+var normalizeOffsetTime = (value) => {
+  if (value instanceof Date) {
+    return `${formatLocalTime(value)}Z`;
+  }
+  const raw = expectString(value, "offset time").trim();
+  if (/^\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(raw)) {
+    return raw;
+  }
+  throw new Error("Expected an offset-time value");
+};
+var normalizeLocalDateTime = (value) => {
+  if (value instanceof Date) {
+    return formatLocalDateTime(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");
+  }
+  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);
+    if (!Number.isNaN(parsed.getTime())) {
+      return formatLocalDateTime(parsed);
+    }
+  }
+  throw new Error("Expected a local-datetime value");
+};
+var normalizeInstant = (value) => {
+  if (value instanceof Date) {
+    return 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);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new Error("Expected an ISO instant value");
+  }
+  return parsed.toISOString();
+};
+var normalizeYear = (value) => {
+  if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 9999) {
+    return pad(value, 4);
+  }
+  const raw = expectString(value, "year").trim();
+  if (/^\d{4}$/.test(raw)) {
+    return raw;
+  }
+  throw new Error("Expected a four-digit year");
+};
+var normalizeBytes = (value) => {
+  if (value instanceof Uint8Array) {
+    return new Uint8Array(value);
+  }
+  const BufferConstructor = globalThis.Buffer;
+  if (BufferConstructor !== undefined && value instanceof BufferConstructor) {
+    return new Uint8Array(value);
+  }
+  throw new Error("Expected a byte array value");
+};
+var isJsonValue = (value) => {
+  if (value === null) {
+    return true;
+  }
+  switch (typeof value) {
+    case "string":
+    case "number":
+    case "boolean":
+      return true;
+    case "object":
+      if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+      }
+      return isRecord(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;
+    }
+    throw new Error("Parsed JSON value is not a valid JSON runtime");
+  }
+  if (isJsonValue(value)) {
+    return value;
+  }
+  throw new Error("Expected a JSON value");
+};
+var normalizeDbValue = (dbType, value) => {
+  if (value === null) {
+    return null;
+  }
+  if ("base" in dbType) {
+    return normalizeDbValue(dbType.base, value);
+  }
+  if ("element" in dbType) {
+    if (!Array.isArray(value)) {
+      throw new Error("Expected an array value");
+    }
+    return value.map((entry) => normalizeDbValue(dbType.element, entry));
+  }
+  if ("fields" in dbType) {
+    if (!isRecord(value)) {
+      throw new Error("Expected a record value");
+    }
+    const normalized = {};
+    for (const [key2, fieldDbType] of Object.entries(dbType.fields)) {
+      if (key2 in value) {
+        normalized[key2] = normalizeDbValue(fieldDbType, value[key2]);
+      }
+    }
+    return normalized;
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return normalizeJson(value);
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return expectString(value, "text");
+  }
+  switch (runtimeTagOfBaseDbType(dbType)) {
+    case "string":
+      return expectString(value, "text");
+    case "number":
+      return normalizeNumber(value);
+    case "bigintString":
+      return normalizeBigIntString(value);
+    case "boolean":
+      return normalizeBoolean(value);
+    case "json":
+      return normalizeJson(value);
+    case "localDate":
+      return normalizeLocalDate(value);
+    case "localTime":
+      return normalizeLocalTime(value);
+    case "offsetTime":
+      return normalizeOffsetTime(value);
+    case "localDateTime":
+      return normalizeLocalDateTime(value);
+    case "instant":
+      return normalizeInstant(value);
+    case "year":
+      return normalizeYear(value);
+    case "decimalString":
+      return normalizeDecimalString(value);
+    case "bytes":
+      return normalizeBytes(value);
+    case "array":
+      if (!Array.isArray(value)) {
+        throw new Error("Expected an array value");
+      }
+      return value;
+    case "record":
+      if (!isRecord(value)) {
+        throw new Error("Expected a record value");
+      }
+      return value;
+    case "null":
+      return null;
+    case "unknown":
+    case undefined:
+      return value;
+  }
+};
+
+// src/internal/runtime/driver-value-mapping.ts
+var runtimeTagOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
+  }
+  if ("base" in dbType) {
+    return runtimeTagOfDbType(dbType.base);
+  }
+  if ("element" in dbType) {
+    return "array";
+  }
+  if ("fields" in dbType) {
+    return "record";
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return "json";
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return "string";
+  }
+  return dbType.runtime;
+};
+var familyOfDbType = (dbType) => {
+  if (dbType === undefined) {
+    return;
+  }
+  if ("base" in dbType) {
+    return familyOfDbType(dbType.base);
+  }
+  return dbType.family;
+};
+var mappingCandidates = (context) => {
+  const dbType = context.dbType;
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  const family = familyOfDbType(dbType);
+  return [
+    context.driverValueMapping,
+    dbType?.driverValueMapping,
+    dbType === undefined ? undefined : context.valueMappings?.[dbType.kind],
+    family === undefined ? undefined : context.valueMappings?.[family],
+    runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
+  ];
+};
+var findMapping = (context, key2) => {
+  for (const candidate of mappingCandidates(context)) {
+    const value = candidate?.[key2];
+    if (value !== undefined) {
+      return value;
+    }
+  }
+  return;
+};
+var encodeWithSchema = (schema2, value) => {
+  if (schema2 === undefined) {
+    return { value, encoded: false };
+  }
+  if (!Schema3.is(schema2)(value)) {
+    return { value, encoded: false };
+  }
+  return {
+    value: Schema3.encodeUnknownSync(schema2)(value),
+    encoded: true
+  };
+};
+var toDriverValue = (value, context) => {
+  if (value === null) {
+    return null;
+  }
+  const dbType = context.dbType;
+  const encoded = encodeWithSchema(context.runtimeSchema, value);
+  let current = encoded.value;
+  const custom = findMapping(context, "toDriver");
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(current, dbType);
+  }
+  return dbType === undefined || !encoded.encoded ? current : normalizeDbValue(dbType, current);
+};
+var fromDriverValue = (value, context) => {
+  if (value === null) {
+    return null;
+  }
+  const dbType = context.dbType;
+  const custom = findMapping(context, "fromDriver");
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(value, dbType);
+  }
+  return dbType === undefined ? value : normalizeDbValue(dbType, value);
+};
+var textCast = (sql) => `(${sql})::text`;
+var postgresJsonSql = (sql, dbType) => {
+  const runtimeTag = runtimeTagOfDbType(dbType);
+  switch (runtimeTag) {
+    case "bigintString":
+    case "decimalString":
+    case "localDate":
+    case "localTime":
+    case "offsetTime":
+    case "localDateTime":
+    case "instant":
+    case "year":
+      return textCast(sql);
+    case "bytes":
+      return `encode(${sql}, 'base64')`;
+    default:
+      return sql;
+  }
+};
+var renderSelectSql = (sql, context) => {
+  const dbType = context.dbType;
+  const custom = findMapping(context, "selectSql");
+  return custom !== undefined && dbType !== undefined ? custom(sql, dbType) : sql;
+};
+var renderJsonSelectSql = (sql, context) => {
+  const dbType = context.dbType;
+  const custom = findMapping(context, "jsonSelectSql");
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(sql, dbType);
+  }
+  return context.dialect === "postgres" && dbType !== undefined ? postgresJsonSql(sql, dbType) : sql;
+};
+
 // src/internal/projection-alias.ts
 var TypeId8 = Symbol.for("effect-qb/ProjectionAlias");
 
@@ -1475,13 +2007,13 @@ var dedupeGroupedExpressions = (values) => {
 var isExpression2 = (value) => typeof value === "object" && value !== null && (TypeId2 in value);
 var selectionHasAggregate = (selection) => {
   if (isExpression2(selection)) {
-    return selection[TypeId2].aggregation === "aggregate";
+    return selection[TypeId2].kind === "aggregate";
   }
   return Object.values(selection).some((value) => selectionHasAggregate(value));
 };
 var isGroupedSelectionValid = (selection, groupedExpressions) => {
   if (isExpression2(selection)) {
-    const aggregation = selection[TypeId2].aggregation;
+    const aggregation = selection[TypeId2].kind;
     if (aggregation === "aggregate") {
       return true;
     }
@@ -1504,7 +2036,7 @@ var validateAggregationSelection = (selection, grouped) => {
   }
 };
 
-// src/internal/sql-expression-renderer.ts
+// src/postgres/internal/sql-expression-renderer.ts
 var renderDbType = (dialect, dbType) => {
   if (dialect.name === "mysql" && dbType.dialect === "mysql" && dbType.kind === "uuid") {
     return "char(36)";
@@ -1688,8 +2220,27 @@ var renderPostgresJsonValue = (value, state, dialect) => {
     throw new Error("Expected a JSON expression");
   }
   const rendered = renderExpression(value, state, dialect);
+  const ast = value[TypeId3];
+  if (ast.kind === "literal") {
+    return `cast(${rendered} as jsonb)`;
+  }
   return value[TypeId2].dbType.kind === "jsonb" ? rendered : `cast(${rendered} as jsonb)`;
 };
+var expressionDriverContext = (expression, state, dialect) => ({
+  dialect: dialect.name,
+  valueMappings: state.valueMappings,
+  dbType: expression[TypeId2].dbType,
+  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 renderPostgresJsonKind = (value) => value[TypeId2].dbType.kind === "jsonb" ? "jsonb" : "json";
 var renderJsonOpaquePath = (value, state, dialect) => {
   if (isJsonPathValue(value)) {
@@ -1818,7 +2369,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
       const entries = Array.isArray(ast.entries) ? ast.entries : [];
       const renderedEntries = entries.flatMap((entry) => [
         dialect.renderLiteral(entry.key, state),
-        renderExpression(entry.value, state, dialect)
+        renderJsonInputExpression(entry.value, state, dialect)
       ]);
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`;
@@ -1830,7 +2381,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
     }
     case "jsonBuildArray": {
       const values = Array.isArray(ast.values) ? ast.values : [];
-      const renderedValues = values.map((value) => renderExpression(value, state, dialect)).join(", ");
+      const renderedValues = values.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ");
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`;
       }
@@ -1844,7 +2395,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        return `to_json(${renderExpression(base, state, dialect)})`;
+        return `to_json(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
         return `cast(${renderExpression(base, state, dialect)} as json)`;
@@ -1855,7 +2406,7 @@ var renderJsonExpression = (expression, ast, state, dialect) => {
         return;
       }
       if (dialect.name === "postgres") {
-        return `to_jsonb(${renderExpression(base, state, dialect)})`;
+        return `to_jsonb(${renderJsonInputExpression(base, state, dialect)})`;
       }
       if (dialect.name === "mysql") {
         return `cast(${renderExpression(base, state, dialect)} as json)`;
@@ -2042,7 +2593,7 @@ var renderSelectionList = (selection, state, dialect, validateAggregation) => {
   }
   const flattened = flattenSelection(selection);
   const projections = selectionProjections(selection);
-  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderExpression(expression, state, dialect)} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
+  const sql = flattened.map(({ expression, alias: alias2 }) => `${renderSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias2)}`).join(", ");
   return {
     sql,
     projections
@@ -2122,11 +2673,11 @@ var renderQueryAst = (ast, state, dialect) => {
         if (dialect.name === "postgres") {
           const table = targetSource.source;
           const fields = table[TypeId4].fields;
-          const rendered = unnestSource.values.map((entry) => `cast(${dialect.renderLiteral(entry.values, state)} as ${renderCastType(dialect, fields[entry.columnName].metadata.dbType)}[])`).join(", ");
+          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(", ");
           sql += ` (${columns}) select * from unnest(${rendered})`;
         } else {
           const rowCount = unnestSource.values[0]?.values.length ?? 0;
-          const rows = Array.from({ length: rowCount }, (_, index3) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state)).join(", ")})`).join(", ");
+          const rows = Array.from({ length: rowCount }, (_, index3) => `(${unnestSource.values.map((entry) => dialect.renderLiteral(entry.values[index3], state, targetSource.source[TypeId4].fields[entry.columnName][TypeId2])).join(", ")})`).join(", ");
           sql += ` (${columns}) values ${rows}`;
         }
       } else {
@@ -2387,11 +2938,13 @@ var renderExpression = (expression, state, dialect) => {
     case "column":
       return ast.tableName.length === 0 ? dialect.quoteIdentifier(ast.columnName) : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`;
     case "literal":
-      return dialect.renderLiteral(ast.value, state);
+      return dialect.renderLiteral(ast.value, state, expression[TypeId2]);
     case "excluded":
       return dialect.name === "mysql" ? `values(${dialect.quoteIdentifier(ast.columnName)})` : `excluded.${dialect.quoteIdentifier(ast.columnName)}`;
     case "cast":
       return `cast(${renderExpression(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(".")})`;
     case "function":
       return renderFunctionCall(ast.name, Array.isArray(ast.args) ? ast.args : [], state, dialect);
     case "eq":
@@ -2522,8 +3075,40 @@ var renderExpression = (expression, state, dialect) => {
   throw new Error("Unsupported expression for SQL rendering");
 };
 
-// src/internal/schema-ddl.ts
+// src/postgres/internal/schema-ddl.ts
 import { parse as parse2, toSql as toSql2 } from "pgsql-ast-parser";
+
+// src/postgres/internal/dialect.ts
+var quoteIdentifier = (value) => `"${value.replaceAll('"', '""')}"`;
+var renderLiteral = (value, state, context = {}) => {
+  const driverValue = toDriverValue(value, {
+    dialect: "postgres",
+    valueMappings: state.valueMappings,
+    ...context
+  });
+  if (driverValue === null) {
+    return "null";
+  }
+  if (typeof driverValue === "boolean") {
+    return driverValue ? "true" : "false";
+  }
+  state.params.push(driverValue);
+  return `$${state.params.length}`;
+};
+var postgresDialect = {
+  name: "postgres",
+  quoteIdentifier,
+  renderLiteral,
+  renderTableReference(tableName, baseTableName, schemaName) {
+    const renderedBase = schemaName ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}` : quoteIdentifier(baseTableName);
+    return tableName === baseTableName ? renderedBase : `${renderedBase} as ${quoteIdentifier(tableName)}`;
+  },
+  renderConcat(values) {
+    return `(${values.join(" || ")})`;
+  }
+};
+
+// src/postgres/internal/schema-ddl.ts
 var escapeString = (value) => `'${value.replaceAll("'", "''")}'`;
 var inlineLiteralDialect = {
   ...postgresDialect,
@@ -2548,17 +3133,56 @@ var renderDdlExpressionSql = (expression) => isSchemaExpression(expression) ? re
   ctes: [],
   cteNames: new Set
 }, inlineLiteralDialect);
+var stripRedundantOuterParens = (value) => {
+  let current = value.trim();
+  while (current.startsWith("(") && current.endsWith(")")) {
+    let depth = 0;
+    let wrapsWholeExpression = true;
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    for (let index3 = 0;index3 < current.length; index3++) {
+      const char = current[index3];
+      const previous = index3 > 0 ? current[index3 - 1] : undefined;
+      if (char === "'" && !inDoubleQuote && previous !== "\\") {
+        inSingleQuote = !inSingleQuote;
+        continue;
+      }
+      if (char === '"' && !inSingleQuote && previous !== "\\") {
+        inDoubleQuote = !inDoubleQuote;
+        continue;
+      }
+      if (inSingleQuote || inDoubleQuote) {
+        continue;
+      }
+      if (char === "(") {
+        depth += 1;
+      } else if (char === ")") {
+        depth -= 1;
+        if (depth === 0 && index3 < current.length - 1) {
+          wrapsWholeExpression = false;
+          break;
+        }
+      }
+    }
+    if (!wrapsWholeExpression) {
+      break;
+    }
+    current = current.slice(1, -1).trim();
+  }
+  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);
   try {
-    return toSql2.expr(parse2(rendered, "expr"));
+    return canonicalizeDdlExpressionSql(toSql2.expr(parse2(rendered, "expr")));
   } catch {
-    return rendered.trim();
+    return canonicalizeDdlExpressionSql(rendered);
   }
 };
 
 // src/postgres/schema-management.ts
-import * as Schema3 from "effect/Schema";
+import * as Schema4 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");
@@ -2577,8 +3201,8 @@ var EnumProto = {
     };
   },
   column() {
-    const values = this.values.map((value) => Schema3.Literal(value));
-    return makeColumnDefinition(values.length === 1 ? values[0] : Schema3.Union(...values), {
+    const values = this.values.map((value) => Schema4.Literal(value));
+    return makeColumnDefinition(values.length === 1 ? values[0] : Schema4.Union(...values), {
       dbType: this.type(),
       nullable: false,
       hasDefault: false,
@@ -2630,7 +3254,7 @@ function sequence(name, schemaName) {
 }
 var isSequenceDefinition = (value) => typeof value === "object" && value !== null && (SequenceTypeId in value);
 
-// src/internal/postgres-schema-model.ts
+// src/postgres/internal/schema-model.ts
 var isTableDefinition = (value) => value !== null && (typeof value === "object" || typeof value === "function") && (TypeId4 in value);
 var isEnumDefinition = (value) => typeof value === "object" && value !== null && (EnumTypeId in value);
 var toTableModel = (table) => {