effect-qb 0.21.0 → 0.22.0

package/dist/index.js

@@ -2457,8 +2457,9 @@ var normalizeOffsetTime = (value) => {
     return `${formatLocalTime(validDate(value))}Z`;
   }
   const raw = expectString(value, "offset time").trim();
-  if (isValidOffsetTimeString(raw)) {
-    return raw;
+  const canonical = raw.replace(/([+-]\d{2})$/, "$1:00").replace(/([+-]\d{2})(\d{2})$/, "$1:$2");
+  if (isValidOffsetTimeString(canonical)) {
+    return canonical;
   }
   throw new Error("Expected an offset-time value");
 };
@@ -3520,6 +3521,14 @@ var castTargetGroupingKey = (target) => {
 };
 var escapeGroupingText = (value) => value.replace(/\\/g, "\\\\").replace(/,/g, "\\,").replace(/\|/g, "\\|").replace(/=/g, "\\=").replace(/>/g, "\\>");
 var functionCallNameGroupingKey = (name) => escapeGroupingText(name);
+var customSqlGroupingKey = (strings, values) => strings.map((part, index4) => {
+  const value = values[index4];
+  if (value === undefined) {
+    return escapeGroupingText(part);
+  }
+  const rendered = isExpression2(value) ? groupingKeyOfExpression(value) : `identifier:${value.parts.map(escapeGroupingText).join(".")}`;
+  return `${escapeGroupingText(part)}${rendered}`;
+}).join("|");
 var quantifiedComparisonGroupingName = (kind) => kind === "comparisonAny" ? "compareAny" : "compareAll";
 var caseGroupingKey = (branches, fallback) => {
   const typedBranches = branches;
@@ -3601,12 +3610,19 @@ var groupingKeyOfExpression = (expression) => {
       return `collate(${requiredExpressionGroupingKey("collate", ast.value)},${collationGroupingKey(ast.collation)})`;
     case "function":
       return `function(${functionCallNameGroupingKey(ast.name)},${functionCallArgsGroupingKey(ast.args)})`;
+    case "customSql":
+      return `customSql(${customSqlGroupingKey(ast.strings, ast.values)})`;
     case "isNull":
     case "isNotNull":
     case "not":
     case "upper":
     case "lower":
     case "count":
+    case "sum":
+    case "avg":
+    case "abs":
+    case "round":
+    case "negate":
     case "max":
     case "min":
       return `${ast.kind}(${requiredExpressionGroupingKey(ast.kind, ast.value)})`;
@@ -3627,6 +3643,11 @@ var groupingKeyOfExpression = (expression) => {
     case "contains":
     case "containedBy":
     case "overlaps":
+    case "add":
+    case "subtract":
+    case "multiply":
+    case "divide":
+    case "modulo":
       return `${ast.kind}(${requiredBinaryExpressionGroupingKey(ast.kind, ast.left, ast.right)})`;
     case "and":
     case "or":
@@ -3702,6 +3723,31 @@ var dedupeGroupedExpressions = (values) => {
   });
 };
 
+// src/internal/window-frame.ts
+var validateBoundary = (boundary) => {
+  if (typeof boundary === "object") {
+    const value = "preceding" in boundary ? boundary.preceding : boundary.following;
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new Error("window frame offsets must be non-negative safe integers");
+    }
+  }
+};
+var validateWindowFrame = (frame) => {
+  if (frame === undefined) {
+    return;
+  }
+  validateBoundary(frame.start);
+  if (frame.end !== undefined) {
+    validateBoundary(frame.end);
+  }
+  if (frame.start === "unboundedFollowing") {
+    throw new Error("window frame cannot start with unbounded following");
+  }
+  if (frame.end === "unboundedPreceding") {
+    throw new Error("window frame cannot end with unbounded preceding");
+  }
+};
+
 // src/internal/dsl-transaction-ddl-runtime.ts
 var renderTransactionIsolationLevel = (isolationLevel) => {
   if (isolationLevel === undefined) {
@@ -5033,6 +5079,10 @@ var extractRequiredFromDialectInputRuntime = (value) => {
   return Object.keys(expression[TypeId].dependencies);
 };
 var normalizeWindowSpec = (spec) => {
+  if (spec?.frame !== undefined) {
+    throw new Error("over does not accept an explicit frame on the portable Function API; use a dialect Function.over helper");
+  }
+  validateWindowFrame(spec?.frame);
   const partitionBy = [...spec?.partitionBy ?? []];
   const orderBy = (spec?.orderBy ?? []).map((term) => {
     const direction = term.direction ?? "asc";
@@ -5043,7 +5093,8 @@ var normalizeWindowSpec = (spec) => {
   });
   return {
     partitionBy,
-    orderBy
+    orderBy,
+    frame: spec?.frame
   };
 };
 var mergeWindowExpressions = (value, partitionBy, orderBy) => value === undefined ? [...partitionBy, ...orderBy.map((term) => term.value)] : [value, ...partitionBy, ...orderBy.map((term) => term.value)];
@@ -5180,34 +5231,6 @@ var isNotNull = (value) => {
     value: expression
   });
 };
-var upper = (value) => {
-  const expression = toDialectStringExpression(value);
-  return makeExpression2({
-    runtime: "",
-    dbType: profile.textDb,
-    nullability: expression[TypeId].nullability,
-    dialect: expression[TypeId].dialect,
-    kind: expression[TypeId].kind,
-    dependencies: expression[TypeId].dependencies
-  }, {
-    kind: "upper",
-    value: expression
-  });
-};
-var lower = (value) => {
-  const expression = toDialectStringExpression(value);
-  return makeExpression2({
-    runtime: "",
-    dbType: profile.textDb,
-    nullability: expression[TypeId].nullability,
-    dialect: expression[TypeId].dialect,
-    kind: expression[TypeId].kind,
-    dependencies: expression[TypeId].dependencies
-  }, {
-    kind: "lower",
-    value: expression
-  });
-};
 var collate = (value, collation) => {
   const expression = toDialectStringExpression(value);
   const normalizedCollation = typeof collation === "string" ? [collation] : collation;
@@ -5737,8 +5760,8 @@ var any_ = (...values) => or(...values);
 var count = (value) => {
   const expression = toDialectExpression(value);
   return makeExpression2({
-    runtime: 0,
-    dbType: profile.numericDb,
+    runtime: undefined,
+    dbType: standardDatatypes.bigint(),
     nullability: "never",
     dialect: expression[TypeId].dialect,
     kind: "aggregate",
@@ -5824,15 +5847,16 @@ var over = (value, spec = {}) => {
     function: "over",
     value,
     partitionBy: normalized.partitionBy,
-    orderBy: normalized.orderBy
+    orderBy: normalized.orderBy,
+    frame: normalized.frame
   });
 };
 var buildNumberWindow = (kind, spec) => {
   const normalized = normalizeWindowSpec(spec);
   const expressions = mergeWindowExpressions(undefined, normalized.partitionBy, normalized.orderBy);
   return makeExpression2({
-    runtime: 0,
-    dbType: profile.numericDb,
+    runtime: undefined,
+    dbType: standardDatatypes.bigint(),
     nullability: "never",
     dialect: expressions.find((expression) => expression[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
     kind: "window",
@@ -5841,7 +5865,8 @@ var buildNumberWindow = (kind, spec) => {
     kind: "window",
     function: kind,
     partitionBy: normalized.partitionBy,
-    orderBy: normalized.orderBy
+    orderBy: normalized.orderBy,
+    frame: normalized.frame
   });
 };
 var rowNumber = (spec) => buildNumberWindow("rowNumber", spec);
@@ -5885,21 +5910,6 @@ var coalesce = (...values) => {
     values: expressions
   });
 };
-var call = (name, ...args) => {
-  const expressions = args.map((value) => toDialectExpression(value));
-  return makeExpression2({
-    runtime: undefined,
-    dbType: profile.textDb,
-    nullability: "maybe",
-    dialect: expressions.find((value) => value[TypeId].dialect !== undefined)?.[TypeId].dialect ?? profile.dialect,
-    kind: mergeAggregationManyRuntime(expressions),
-    dependencies: mergeManyDependencies(expressions)
-  }, {
-    kind: "function",
-    name,
-    args: expressions
-  });
-};
 var resolveCaseNullabilityRuntime = (values) => {
   let sawNever = false;
   let sawMaybe = false;
@@ -6389,39 +6399,78 @@ var {
 
 // src/standard/cast.ts
 var to = (...args) => args.length === 1 ? (value) => cast(value, args[0]) : cast(args[0], args[1]);
+// src/standard/type.ts
+var driverValueMapping4 = (dbType, mapping) => ({
+  ...dbType,
+  driverValueMapping: mapping
+});
+var type2 = {
+  ...standardDatatypes,
+  driverValueMapping: driverValueMapping4
+};
+// src/internal/fragment.ts
+var exports_fragment = {};
+__export(exports_fragment, {
+  identifier: () => identifier,
+  expression: () => expression
+});
+var identifier = (...parts) => ({
+  kind: "sqlIdentifier",
+  parts
+});
+var expression = (options2) => (strings, ...values2) => {
+  const expressions = values2.filter((value) => (TypeId in value));
+  return makeExpression2({
+    runtime: undefined,
+    dbType: options2.dbType,
+    runtimeSchema: options2.schema,
+    driverValueMapping: options2.dbType.driverValueMapping,
+    nullability: options2.nullability,
+    dialect: expressions.find((value) => value[TypeId].dialect !== "standard")?.[TypeId].dialect ?? expressions[0]?.[TypeId].dialect ?? options2.dbType.dialect,
+    kind: options2.kind ?? mergeAggregationManyRuntime(expressions),
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "customSql",
+    strings: [...strings],
+    values: values2
+  });
+};
 // src/standard/function/index.ts
 var exports_function = {};
 __export(exports_function, {
   window: () => exports_window,
-  upper: () => upper,
-  temporal: () => exports_temporal,
+  subtract: () => subtract,
   string: () => exports_string,
   rowNumber: () => rowNumber,
   rank: () => rank,
   over: () => over,
-  now: () => now,
+  negate: () => negate,
+  multiply: () => multiply,
   min: () => min,
   max: () => max,
-  lower: () => lower,
-  localTimestamp: () => localTimestamp,
-  localTime: () => localTime,
+  lead: () => lead,
+  lastValue: () => lastValue,
+  lag: () => lag,
+  firstValue: () => firstValue,
   denseRank: () => denseRank,
-  currentTimestamp: () => currentTimestamp,
-  currentTime: () => currentTime,
-  currentDate: () => currentDate,
   count: () => count,
   core: () => exports_core,
   concat: () => concat,
   coalesce: () => coalesce,
-  call: () => call,
-  aggregate: () => exports_aggregate
+  aggregate: () => exports_aggregate,
+  add: () => add,
+  abs: () => abs
 });
 
 // src/standard/function/core.ts
 var exports_core = {};
 __export(exports_core, {
+  subtract: () => subtract,
+  negate: () => negate,
+  multiply: () => multiply,
   coalesce: () => coalesce,
-  call: () => call
+  add: () => add,
+  abs: () => abs
 });
 
 // src/standard/query.ts
@@ -6430,17 +6479,17 @@ __export(exports_query, {
   withRecursive: () => withRecursive_,
   with: () => with_,
   where: () => where,
+  when: () => when,
   values: () => exportedValues,
   upsert: () => upsert,
-  upper: () => upper,
   update: () => update,
   unnest: () => exportedUnnest,
   union_query_capabilities: () => union_query_capabilities,
   unionAll: () => unionAll,
   union: () => union,
-  type: () => type,
   truncate: () => truncate,
   transaction: () => transaction,
+  subtract: () => subtract,
   select: () => exportedSelect,
   scalar: () => scalar,
   savepoint: () => savepoint,
@@ -6458,25 +6507,30 @@ __export(exports_query, {
   overlaps: () => overlaps,
   over: () => over,
   orderBy: () => orderBy,
+  orAll: () => orAll,
   or: () => or,
   onConflict: () => onConflict,
   offset: () => offset,
   notIn: () => notIn,
   not: () => not,
   neq: () => neq,
+  negate: () => negate,
+  multiply: () => multiply,
   min: () => min,
   merge: () => merge2,
   max: () => max,
   match: () => match,
   lte: () => lte,
   lt: () => lt,
-  lower: () => lower,
   lock: () => lock,
   literal: () => literal,
   limit: () => limit,
   like: () => like,
   leftJoin: () => leftJoin,
+  lead: () => lead,
   lateral: () => lateral,
+  lastValue: () => lastValue,
+  lag: () => lag,
   isNull: () => isNull,
   isNotNull: () => isNotNull,
   isNotDistinctFrom: () => isNotDistinctFrom,
@@ -6485,6 +6539,7 @@ __export(exports_query, {
   intersect: () => intersect,
   insert: () => exportedInsert,
   innerJoin: () => innerJoin,
+  includeIf: () => includeIf,
   inSubquery: () => inSubquery,
   in: () => in_,
   ilike: () => ilike,
@@ -6494,6 +6549,7 @@ __export(exports_query, {
   groupBy: () => groupBy,
   fullJoin: () => fullJoin,
   from: () => exportedFrom,
+  firstValue: () => firstValue,
   exists: () => exists,
   excluded: () => excluded,
   exceptAll: () => exceptAll,
@@ -6519,18 +6575,214 @@ __export(exports_query, {
   coalesce: () => coalesce,
   cast: () => cast,
   case: () => case_,
-  call: () => call,
   between: () => between,
   as: () => as,
   any: () => any_,
+  andAll: () => andAll,
   and: () => and,
-  all: () => all_
+  all: () => all_,
+  add: () => add,
+  abs: () => abs
+});
+
+// src/internal/numeric.ts
+import * as Schema7 from "effect/Schema";
+var numberLiteral = (value) => makeExpression2({
+  runtime: value,
+  dbType: standardDatatypes.real(),
+  runtimeSchema: Schema7.Number,
+  nullability: "never",
+  dialect: "standard",
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "literal",
+  value
 });
+var toExpression = (value) => typeof value === "number" ? numberLiteral(value) : value;
+var retargetLiteral = (value, target) => {
+  const ast = value[TypeId2];
+  if (ast.kind !== "literal") {
+    return value;
+  }
+  const state = target[TypeId];
+  return makeExpression2({
+    runtime: value[TypeId].runtime,
+    dbType: state.dbType,
+    runtimeSchema: state.runtimeSchema,
+    driverValueMapping: state.driverValueMapping,
+    nullability: value[TypeId].nullability,
+    dialect: state.dialect,
+    kind: "scalar",
+    dependencies: {}
+  }, ast);
+};
+var binary = (kind, left, right) => {
+  let leftExpression = toExpression(left);
+  let rightExpression = toExpression(right);
+  const leftAst = leftExpression[TypeId2];
+  const rightAst = rightExpression[TypeId2];
+  if (leftAst.kind === "literal" && rightAst.kind !== "literal") {
+    leftExpression = retargetLiteral(leftExpression, rightExpression);
+  } else if (rightAst.kind === "literal" && leftAst.kind !== "literal") {
+    rightExpression = retargetLiteral(rightExpression, leftExpression);
+  }
+  const values2 = [leftExpression, rightExpression];
+  return makeExpression2({
+    runtime: 0,
+    dbType: leftExpression[TypeId].dbType,
+    runtimeSchema: Schema7.Number,
+    driverValueMapping: leftExpression[TypeId].driverValueMapping,
+    nullability: mergeNullabilityManyRuntime(values2),
+    dialect: values2.find((value) => value[TypeId].dialect !== "standard")?.[TypeId].dialect ?? leftExpression[TypeId].dialect,
+    kind: mergeAggregationManyRuntime(values2),
+    dependencies: mergeManyDependencies(values2)
+  }, {
+    kind,
+    left: leftExpression,
+    right: rightExpression
+  });
+};
+var add = (left, right) => binary("add", left, right);
+var subtract = (left, right) => binary("subtract", left, right);
+var multiply = (left, right) => binary("multiply", left, right);
+var unary = (kind, value, nullability, resultKind) => {
+  const expression2 = toExpression(value);
+  return makeExpression2({
+    runtime: 0,
+    dbType: expression2[TypeId].dbType,
+    runtimeSchema: Schema7.Number,
+    driverValueMapping: expression2[TypeId].driverValueMapping,
+    nullability,
+    dialect: expression2[TypeId].dialect,
+    kind: resultKind,
+    dependencies: expression2[TypeId].dependencies
+  }, {
+    kind,
+    value: expression2
+  });
+};
+var abs = (value) => {
+  const expression2 = toExpression(value);
+  return unary("abs", value, expression2[TypeId].nullability, expression2[TypeId].kind);
+};
+var negate = (value) => {
+  const expression2 = toExpression(value);
+  return unary("negate", value, expression2[TypeId].nullability, expression2[TypeId].kind);
+};
+// src/internal/dynamic.ts
+import * as Schema8 from "effect/Schema";
+var booleanLiteral = (value) => makeExpression2({
+  runtime: value,
+  dbType: standardDatatypes.boolean(),
+  runtimeSchema: Schema8.Boolean,
+  nullability: "never",
+  dialect: "standard",
+  kind: "scalar",
+  dependencies: {}
+}, {
+  kind: "literal",
+  value
+});
+var combine = (kind, values2, identity) => {
+  if (values2.length === 0) {
+    return booleanLiteral(identity);
+  }
+  const expressions = values2.map((value) => typeof value === "boolean" ? booleanLiteral(value) : value);
+  return makeExpression2({
+    runtime: identity,
+    dbType: standardDatatypes.boolean(),
+    runtimeSchema: Schema8.Boolean,
+    nullability: mergeNullabilityManyRuntime(expressions),
+    dialect: expressions.find((value) => value[TypeId].dialect !== "standard")?.[TypeId].dialect ?? expressions[0][TypeId].dialect,
+    kind: "scalar",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind,
+    values: expressions
+  });
+};
+var andAll = (values2) => combine("and", values2, true);
+var orAll = (values2) => combine("or", values2, false);
+var when = (condition, modifier) => (value) => condition ? modifier(value) : value;
+var includeIf = (condition, selection) => condition ? selection : {};
+// src/internal/analytics.ts
+var normalizeSpec = (spec) => {
+  validateWindowFrame(spec.frame);
+  return {
+    partitionBy: spec.partitionBy ?? [],
+    orderBy: spec.orderBy.map((term) => ({
+      value: term.value,
+      direction: term.direction ?? "asc"
+    })),
+    frame: spec.frame
+  };
+};
+var rejectExplicitPortableFrame = (functionName, spec) => {
+  if (spec.frame !== undefined) {
+    throw new Error(`${functionName} does not accept an explicit frame on the portable Function API; use a dialect Function helper`);
+  }
+};
+var windowExpression = (kind, value, spec, nullability, options2 = {}) => {
+  const normalized = normalizeSpec(spec);
+  const { fallbackDialect, ...astOptions } = options2;
+  const expressions = [
+    value,
+    ...normalized.partitionBy,
+    ...normalized.orderBy.map((term) => term.value),
+    ...options2.offset === undefined ? [] : [options2.offset],
+    ...options2.defaultValue === undefined ? [] : [options2.defaultValue]
+  ];
+  return makeExpression2({
+    runtime: undefined,
+    dbType: value[TypeId].dbType,
+    runtimeSchema: value[TypeId].runtimeSchema,
+    driverValueMapping: value[TypeId].driverValueMapping,
+    nullability,
+    dialect: expressions.find((entry) => entry[TypeId].dialect !== "standard")?.[TypeId].dialect ?? fallbackDialect ?? value[TypeId].dialect,
+    kind: "window",
+    dependencies: mergeManyDependencies(expressions)
+  }, {
+    kind: "window",
+    function: kind,
+    value,
+    ...astOptions,
+    ...normalized
+  });
+};
+var lag = (value, options2) => {
+  rejectExplicitPortableFrame("lag", options2.spec);
+  if (options2.offset !== undefined && (!Number.isSafeInteger(options2.offset) || options2.offset < 0)) {
+    throw new Error("lag offset must be a non-negative safe integer");
+  }
+  return windowExpression("lag", value, options2.spec, "maybe", {
+    ...options2.offset === undefined && options2.default === undefined ? {} : { offset: literal(options2.offset ?? 1) },
+    ...options2.default === undefined ? {} : { defaultValue: literal(options2.default) }
+  });
+};
+var lead = (value, options2) => {
+  rejectExplicitPortableFrame("lead", options2.spec);
+  if (options2.offset !== undefined && (!Number.isSafeInteger(options2.offset) || options2.offset < 0)) {
+    throw new Error("lead offset must be a non-negative safe integer");
+  }
+  return windowExpression("lead", value, options2.spec, "maybe", {
+    ...options2.offset === undefined && options2.default === undefined ? {} : { offset: literal(options2.offset ?? 1) },
+    ...options2.default === undefined ? {} : { defaultValue: literal(options2.default) }
+  });
+};
+var firstValue = (value, spec) => {
+  rejectExplicitPortableFrame("firstValue", spec);
+  return windowExpression("firstValue", value, spec, value[TypeId].nullability);
+};
+var lastValue = (value, spec) => {
+  rejectExplicitPortableFrame("lastValue", spec);
+  return windowExpression("lastValue", value, spec, value[TypeId].nullability);
+};
+var makeDialectFirstValue = (dialect) => (value, spec) => windowExpression("firstValue", value, spec, "maybe", { fallbackDialect: dialect });
+var makeDialectLastValue = (dialect) => (value, spec) => windowExpression("lastValue", value, spec, "maybe", { fallbackDialect: dialect });
 // src/standard/function/string.ts
 var exports_string = {};
 __export(exports_string, {
-  upper: () => upper,
-  lower: () => lower,
   concat: () => concat
 });
 // src/standard/function/aggregate.ts
@@ -6546,37 +6798,12 @@ __export(exports_window, {
   rowNumber: () => rowNumber,
   rank: () => rank,
   over: () => over,
+  lead: () => lead,
+  lastValue: () => lastValue,
+  lag: () => lag,
+  firstValue: () => firstValue,
   denseRank: () => denseRank
 });
-// src/standard/function/temporal.ts
-var exports_temporal = {};
-__export(exports_temporal, {
-  now: () => now,
-  localTimestamp: () => localTimestamp,
-  localTime: () => localTime,
-  currentTimestamp: () => currentTimestamp,
-  currentTime: () => currentTime,
-  currentDate: () => currentDate
-});
-var makeTemporal = (name, dbType, runtimeSchema) => makeExpression2({
-  runtime: undefined,
-  dbType,
-  runtimeSchema,
-  nullability: "never",
-  dialect: "standard",
-  kind: "scalar",
-  dependencies: {}
-}, {
-  kind: "function",
-  name,
-  args: []
-});
-var now = () => makeTemporal("now", standardDatatypes.timestamp(), InstantStringSchema);
-var currentDate = () => makeTemporal("current_date", standardDatatypes.date(), LocalDateStringSchema);
-var currentTime = () => makeTemporal("current_time", standardDatatypes.time(), LocalTimeStringSchema);
-var currentTimestamp = () => makeTemporal("current_timestamp", standardDatatypes.timestamp(), LocalDateTimeStringSchema);
-var localTime = () => makeTemporal("localtime", standardDatatypes.time(), LocalTimeStringSchema);
-var localTimestamp = () => makeTemporal("localtimestamp", standardDatatypes.timestamp(), LocalDateTimeStringSchema);
 // src/standard/json.ts
 var exports_json = {};
 __export(exports_json, {
@@ -6811,27 +7038,32 @@ var pathExists = (...args) => {
 var exports_executor = {};
 __export(exports_executor, {
   withTransaction: () => withTransaction,
+  withResultContracts: () => withResultContracts,
   streamFromSqlClient: () => streamFromSqlClient,
   remapRows: () => remapRows,
+  nonEmpty: () => nonEmpty,
   makeRowDecoder: () => makeRowDecoder,
   make: () => make3,
   hasWriteCapability: () => hasWriteCapability,
   fromSqlClient: () => fromSqlClient,
   fromDriver: () => fromDriver,
+  explainQuery: () => explainQuery,
+  exactlyOne: () => exactlyOne,
   driver: () => driver,
   decodeRows: () => decodeRows,
-  decodeChunk: () => decodeChunk
+  decodeChunk: () => decodeChunk,
+  atMostOne: () => atMostOne
 });
 import * as Chunk from "effect/Chunk";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import * as Option from "effect/Option";
-import * as Schema9 from "effect/Schema";
+import * as Schema11 from "effect/Schema";
 import * as SqlClient from "effect/unstable/sql/SqlClient";
 import * as Stream from "effect/Stream";
 
 // src/internal/runtime/driver-value-mapping.ts
-import * as Schema7 from "effect/Schema";
+import * as Schema9 from "effect/Schema";
 var runtimeTagOfDbType = (dbType) => {
   if (dbType === undefined) {
     return;
@@ -6896,16 +7128,16 @@ var isJsonDbType = (dbType) => {
   const variant = dbType.variant;
   return variant === "json" || variant === "jsonb";
 };
-var schemaAccepts = (schema3, value) => schema3 !== undefined && Schema7.is(schema3)(value);
+var schemaAccepts = (schema3, value) => schema3 !== undefined && Schema9.is(schema3)(value);
 var encodeWithSchema = (schema3, value) => {
   if (schema3 === undefined) {
     return { value, encoded: false };
   }
-  if (!Schema7.is(schema3)(value)) {
+  if (!Schema9.is(schema3)(value)) {
     return { value, encoded: false };
   }
   return {
-    value: Schema7.encodeUnknownSync(schema3)(value),
+    value: Schema9.encodeUnknownSync(schema3)(value),
     encoded: true
   };
 };
@@ -7001,20 +7233,20 @@ var renderJsonSelectSql = (sql, context) => {
 };
 
 // src/internal/runtime/schema.ts
-import * as Schema8 from "effect/Schema";
+import * as Schema10 from "effect/Schema";
 import * as SchemaAST from "effect/SchemaAST";
 var schemaCache = new WeakMap;
-var FiniteNumberSchema = Schema8.Number.check(Schema8.isFinite());
+var FiniteNumberSchema = Schema10.Number.check(Schema10.isFinite());
 var runtimeSchemaForTag = (tag) => {
   switch (tag) {
     case "string":
-      return Schema8.String;
+      return Schema10.String;
     case "number":
       return FiniteNumberSchema;
     case "bigintString":
       return BigIntStringSchema;
     case "boolean":
-      return Schema8.Boolean;
+      return Schema10.Boolean;
     case "json":
       return JsonValueSchema;
     case "localDate":
@@ -7032,13 +7264,13 @@ var runtimeSchemaForTag = (tag) => {
     case "decimalString":
       return DecimalStringSchema;
     case "bytes":
-      return Schema8.Uint8Array;
+      return Schema10.Uint8Array;
     case "array":
-      return Schema8.Array(Schema8.Unknown);
+      return Schema10.Array(Schema10.Unknown);
     case "record":
-      return Schema8.Record(Schema8.String, Schema8.Unknown);
+      return Schema10.Record(Schema10.String, Schema10.Unknown);
     case "null":
-      return Schema8.Null;
+      return Schema10.Null;
     case "unknown":
       return;
   }
@@ -7051,22 +7283,22 @@ var runtimeSchemaForDbType = (dbType) => {
     return runtimeSchemaForDbType(dbType.base);
   }
   if ("element" in dbType) {
-    return Schema8.Array(runtimeSchemaForDbType(dbType.element) ?? Schema8.Unknown);
+    return Schema10.Array(runtimeSchemaForDbType(dbType.element) ?? Schema10.Unknown);
   }
   if ("fields" in dbType) {
-    const fields = Object.fromEntries(Object.entries(dbType.fields).map(([key3, field]) => [key3, runtimeSchemaForDbType(field) ?? Schema8.Unknown]));
-    return Schema8.Struct(fields);
+    const fields = Object.fromEntries(Object.entries(dbType.fields).map(([key3, field]) => [key3, runtimeSchemaForDbType(field) ?? Schema10.Unknown]));
+    return Schema10.Struct(fields);
   }
   if ("variant" in dbType && dbType.variant === "json") {
     return JsonValueSchema;
   }
   if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
-    return Schema8.String;
+    return Schema10.String;
   }
   const runtimeTag = runtimeTagOfBaseDbType2(dbType);
   return runtimeTag === undefined ? undefined : runtimeSchemaForTag(runtimeTag);
 };
-var makeSchemaFromAst = (ast) => Schema8.make(ast);
+var makeSchemaFromAst = (ast) => Schema10.make(ast);
 var unionAst = (asts) => {
   if (asts.length === 0) {
     return;
@@ -7156,7 +7388,7 @@ var unionSchemas = (schemas) => {
   if (resolved.length === 1) {
     return resolved[0];
   }
-  return Schema8.Union(resolved);
+  return Schema10.Union(resolved);
 };
 var firstSelectedExpression = (plan) => {
   const selection = getAst(plan).select;
@@ -7191,9 +7423,9 @@ var jsonCompatibleSchema = (schema3) => {
 };
 var buildStructSchema = (entries, context) => {
   const fields = Object.fromEntries(entries.map((entry) => [entry.key, expressionRuntimeSchema(entry.value, context) ?? JsonValueSchema]));
-  return Schema8.Struct(fields);
+  return Schema10.Struct(fields);
 };
-var buildTupleSchema = (values2, context) => Schema8.Tuple(values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
+var buildTupleSchema = (values2, context) => Schema10.Tuple(values2.map((value) => expressionRuntimeSchema(value, context) ?? JsonValueSchema));
 var deriveCaseSchema = (ast, context) => {
   if (context === undefined) {
     return unionSchemas([
@@ -7221,22 +7453,22 @@ var deriveCaseSchema = (ast, context) => {
   const elseSchema = expressionRuntimeSchema(ast.else, { assumptions: elseAssumptions });
   return unionSchemas(elseSchema === undefined ? schemas : [...schemas, elseSchema]);
 };
-var deriveRuntimeSchema = (expression, context) => {
-  const state = expression[TypeId];
+var deriveRuntimeSchema = (expression2, context) => {
+  const state = expression2[TypeId];
   if (state.runtimeSchema !== undefined) {
     return state.runtimeSchema;
   }
-  const ast = expression[TypeId2];
+  const ast = expression2[TypeId2];
   switch (ast.kind) {
     case "column":
     case "excluded":
       return state.runtimeSchema;
     case "literal":
       if (ast.value === null) {
-        return Schema8.Null;
+        return Schema10.Null;
       }
       if (typeof ast.value === "string" || typeof ast.value === "number" || typeof ast.value === "boolean") {
-        return Schema8.Literal(ast.value);
+        return Schema10.Literal(ast.value);
       }
       return runtimeSchemaForDbType(state.dbType);
     case "cast":
@@ -7272,7 +7504,7 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonHasAllKeys":
     case "jsonPathExists":
     case "jsonPathMatch":
-      return Schema8.Boolean;
+      return Schema10.Boolean;
     case "upper":
     case "lower":
     case "concat":
@@ -7281,8 +7513,9 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonAccessText":
     case "jsonTraverseText":
     case "jsonTypeOf":
-      return Schema8.String;
+      return Schema10.String;
     case "count":
+      return runtimeSchemaForDbType(state.dbType);
     case "jsonLength":
       return FiniteNumberSchema;
     case "max":
@@ -7297,7 +7530,7 @@ var deriveRuntimeSchema = (expression, context) => {
       return selection === undefined ? undefined : expressionRuntimeSchema(selection, context);
     }
     case "window":
-      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : FiniteNumberSchema;
+      return ast.function === "over" && ast.value !== undefined ? expressionRuntimeSchema(ast.value, context) : runtimeSchemaForDbType(state.dbType);
     case "jsonGet":
     case "jsonPath":
     case "jsonAccess":
@@ -7329,23 +7562,102 @@ var deriveRuntimeSchema = (expression, context) => {
     case "jsonToJsonb":
       return jsonCompatibleSchema(expressionRuntimeSchema(ast.value, context));
     case "jsonKeys":
-      return Schema8.Array(Schema8.String);
+      return Schema10.Array(Schema10.String);
   }
 };
-var expressionRuntimeSchema = (expression, context) => {
+var expressionRuntimeSchema = (expression2, context) => {
   if (context !== undefined) {
-    return deriveRuntimeSchema(expression, context) ?? runtimeSchemaForDbType(expression[TypeId].dbType);
+    return deriveRuntimeSchema(expression2, context) ?? runtimeSchemaForDbType(expression2[TypeId].dbType);
   }
-  const cached = schemaCache.get(expression);
-  if (cached !== undefined || schemaCache.has(expression)) {
+  const cached = schemaCache.get(expression2);
+  if (cached !== undefined || schemaCache.has(expression2)) {
     return cached;
   }
-  const resolved = deriveRuntimeSchema(expression) ?? runtimeSchemaForDbType(expression[TypeId].dbType);
-  schemaCache.set(expression, resolved);
+  const resolved = deriveRuntimeSchema(expression2) ?? runtimeSchemaForDbType(expression2[TypeId].dbType);
+  schemaCache.set(expression2, resolved);
   return resolved;
 };
 
+// src/internal/renderer.ts
+var TypeId10 = Symbol.for("effect-qb/Renderer");
+var projectionPathKey = (path2) => JSON.stringify(path2);
+var formatProjectionPath2 = (path2) => path2.join(".");
+var validateProjectionPathsMatchSelection = (plan, projections) => {
+  const expected = flattenSelection(getAst(plan).select);
+  const expectedPaths = new Set(expected.map((projection) => projectionPathKey(projection.path)));
+  const actualPaths = new Set(projections.map((projection) => projectionPathKey(projection.path)));
+  for (const projection of projections) {
+    if (!expectedPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} does not exist in the query selection`);
+    }
+  }
+  for (const projection of expected) {
+    if (!actualPaths.has(projectionPathKey(projection.path))) {
+      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} is missing from rendered projections`);
+    }
+  }
+};
+function makeTrusted(dialect, render2) {
+  return makeRenderer(dialect, render2, false);
+}
+var makeRenderer = (dialect, render2, validate) => {
+  if (typeof render2 !== "function") {
+    throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`);
+  }
+  return {
+    dialect,
+    render(plan) {
+      const rendered = render2(plan);
+      const projections = rendered.projections ?? [];
+      if (validate) {
+        validateProjections(projections);
+        validateProjectionPathsMatchSelection(plan, projections);
+      }
+      return {
+        sql: rendered.sql,
+        params: rendered.params ?? [],
+        projections,
+        valueMappings: rendered.valueMappings,
+        dialect,
+        [TypeId10]: {
+          row: undefined,
+          dialect
+        }
+      };
+    }
+  };
+};
+
 // src/internal/executor.ts
+var atMostOne = (self) => Effect.flatMap(self, (rows) => rows.length <= 1 ? Effect.succeed(rows.length === 0 ? Option.none() : Option.some(rows[0])) : Effect.fail({
+  _tag: "ResultCardinalityError",
+  expected: "zeroOrOne",
+  actual: rows.length
+}));
+var exactlyOne = (self) => Effect.flatMap(self, (rows) => rows.length === 1 ? Effect.succeed(rows[0]) : Effect.fail({
+  _tag: "ResultCardinalityError",
+  expected: "exactlyOne",
+  actual: rows.length
+}));
+var nonEmpty = (self) => Effect.flatMap(self, (rows) => rows.length > 0 ? Effect.succeed(rows) : Effect.fail({
+  _tag: "ResultCardinalityError",
+  expected: "nonEmpty",
+  actual: 0
+}));
+var withResultContracts = (base) => {
+  const executeResult = base.executeResult ?? ((plan) => Effect.map(base.execute(plan), (rows) => ({ rows })));
+  return {
+    ...base,
+    executeResult,
+    prepare(plan) {
+      return {
+        execute: base.execute(plan),
+        executeResult: executeResult(plan),
+        stream: base.stream(plan)
+      };
+    }
+  };
+};
 var setPath2 = (target, path2, value) => {
   let current = target;
   for (let index5 = 0;index5 < path2.length - 1; index5++) {
@@ -7399,8 +7711,8 @@ var remapRows = (query, rows) => rows.map((row) => {
   }
   return decoded;
 });
-var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, normalized) => {
-  const schemaError = Schema9.isSchemaError(cause) ? {
+var makeRowDecodeError = (rendered, projection, expression2, raw, stage, cause, normalized) => {
+  const schemaError = Schema11.isSchemaError(cause) ? {
     message: cause.message,
     issue: cause.issue
   } : undefined;
@@ -7416,7 +7728,7 @@ var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, n
       alias: projection.alias,
       path: projection.path
     },
-    dbType: expression[TypeId].dbType,
+    dbType: expression2[TypeId].dbType,
     raw,
     normalized,
     stage,
@@ -7424,13 +7736,13 @@ var makeRowDecodeError = (rendered, projection, expression, raw, stage, cause, n
     ...schemaError === undefined ? {} : { schemaError }
   };
 };
-var hasOptionalSourceDependency = (expression, scope) => {
-  const state = expression[TypeId];
+var hasOptionalSourceDependency = (expression2, scope) => {
+  const state = expression2[TypeId];
   return Object.keys(state.dependencies).some((sourceName) => !scope.absentSourceNames.has(sourceName) && scope.sourceModes.get(sourceName) === "optional");
 };
-var effectiveRuntimeNullability = (expression, scope) => {
-  const nullability = expression[TypeId].nullability;
-  const ast = expression[TypeId2];
+var effectiveRuntimeNullability = (expression2, scope) => {
+  const nullability = expression2[TypeId].nullability;
+  const ast = expression2[TypeId2];
   if (nullability === "always") {
     return "always";
   }
@@ -7443,10 +7755,10 @@ var effectiveRuntimeNullability = (expression, scope) => {
       return "never";
     }
   }
-  if (Object.keys(expression[TypeId].dependencies).some((sourceName) => scope.absentSourceNames.has(sourceName))) {
+  if (Object.keys(expression2[TypeId].dependencies).some((sourceName) => scope.absentSourceNames.has(sourceName))) {
     return "always";
   }
-  return hasOptionalSourceDependency(expression, scope) ? "maybe" : nullability;
+  return hasOptionalSourceDependency(expression2, scope) ? "maybe" : nullability;
 };
 var dbTypeAllowsTopLevelJsonNull = (dbType) => {
   if ("base" in dbType) {
@@ -7454,46 +7766,46 @@ var dbTypeAllowsTopLevelJsonNull = (dbType) => {
   }
   return "variant" in dbType && dbType.variant === "json" || dbType.runtime === "json";
 };
-var schemaAcceptsNull = (schema3) => schema3 !== undefined && Schema9.is(schema3)(null);
-var decodeProjectionValue = (rendered, projection, expression, raw, scope, driverMode, valueMappings) => {
+var schemaAcceptsNull = (schema3) => schema3 !== undefined && Schema11.is(schema3)(null);
+var decodeProjectionValue = (rendered, projection, expression2, raw, scope, driverMode, valueMappings) => {
   let normalized = raw;
   if (driverMode === "raw") {
     try {
       normalized = fromDriverValue(raw, {
         dialect: rendered.dialect,
-        dbType: expression[TypeId].dbType,
-        runtimeSchema: expression[TypeId].runtimeSchema,
-        driverValueMapping: expression[TypeId].driverValueMapping,
+        dbType: expression2[TypeId].dbType,
+        runtimeSchema: expression2[TypeId].runtimeSchema,
+        driverValueMapping: expression2[TypeId].driverValueMapping,
         valueMappings
       });
     } catch (cause2) {
-      throw makeRowDecodeError(rendered, projection, expression, raw, "normalize", cause2);
+      throw makeRowDecodeError(rendered, projection, expression2, raw, "normalize", cause2);
     }
   }
-  const nullability = effectiveRuntimeNullability(expression, scope);
-  const schema3 = expressionRuntimeSchema(expression, { assumptions: scope.assumptions });
+  const nullability = effectiveRuntimeNullability(expression2, scope);
+  const schema3 = expressionRuntimeSchema(expression2, { assumptions: scope.assumptions });
   if (normalized === null) {
     if (nullability === "never") {
-      if (dbTypeAllowsTopLevelJsonNull(expression[TypeId].dbType) && schemaAcceptsNull(schema3)) {
+      if (dbTypeAllowsTopLevelJsonNull(expression2[TypeId].dbType) && schemaAcceptsNull(schema3)) {
         return null;
       }
-      throw makeRowDecodeError(rendered, projection, expression, raw, "schema", new Error("Received null for a non-null projection"), normalized);
+      throw makeRowDecodeError(rendered, projection, expression2, raw, "schema", new Error("Received null for a non-null projection"), normalized);
     }
     return null;
   }
   if (nullability === "always") {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", new Error("Received non-null for an always-null projection"), normalized);
+    throw makeRowDecodeError(rendered, projection, expression2, raw, "schema", new Error("Received non-null for an always-null projection"), normalized);
   }
-  if (dbTypeAllowsTopLevelJsonNull(expression[TypeId].dbType) && !isJsonValue(normalized)) {
-    throw makeRowDecodeError(rendered, projection, expression, raw, "schema", new Error("Expected a JSON value"), normalized);
+  if (dbTypeAllowsTopLevelJsonNull(expression2[TypeId].dbType) && !isJsonValue(normalized)) {
+    throw makeRowDecodeError(rendered, projection, expression2, raw, "schema", new Error("Expected a JSON value"), normalized);
   }
   if (schema3 === undefined) {
     return normalized;
   }
-  if (Schema9.is(schema3)(normalized)) {
+  if (Schema11.is(schema3)(normalized)) {
     return normalized;
   }
-  const decoded = Schema9.decodeUnknownExit(schema3)(normalized);
+  const decoded = Schema11.decodeUnknownExit(schema3)(normalized);
   if (Exit.isSuccess(decoded)) {
     return decoded.value;
   }
@@ -7501,7 +7813,7 @@ var decodeProjectionValue = (rendered, projection, expression, raw, scope, drive
     onNone: () => decoded.cause,
     onSome: (schemaError) => schemaError
   });
-  throw makeRowDecodeError(rendered, projection, expression, raw, "schema", cause, normalized);
+  throw makeRowDecodeError(rendered, projection, expression2, raw, "schema", cause, normalized);
 };
 var makeRowDecoder = (rendered, plan, options2 = {}) => {
   const projections = flattenSelection(getAst(plan).select);
@@ -7512,14 +7824,14 @@ var makeRowDecoder = (rendered, plan, options2 = {}) => {
   return (row) => {
     const decoded = {};
     for (const projection of rendered.projections) {
-      const expression = byPath.get(JSON.stringify(projection.path));
-      if (expression === undefined) {
+      const expression2 = byPath.get(JSON.stringify(projection.path));
+      if (expression2 === undefined) {
         throw new Error(`Rendered projection path '${projection.path.join(".")}' does not exist in the query selection`);
       }
       if (!(projection.alias in row)) {
-        throw makeRowDecodeError(rendered, projection, expression, undefined, "schema", new Error(`Missing required projection alias '${projection.alias}'`));
+        throw makeRowDecodeError(rendered, projection, expression2, undefined, "schema", new Error(`Missing required projection alias '${projection.alias}'`));
       }
-      setPath2(decoded, projection.path, decodeProjectionValue(rendered, projection, expression, row[projection.alias], scope, driverMode, valueMappings));
+      setPath2(decoded, projection.path, decodeProjectionValue(rendered, projection, expression2, row[projection.alias], scope, driverMode, valueMappings));
     }
     return decoded;
   };
@@ -7532,7 +7844,7 @@ var decodeRows = (rendered, plan, rows, options2 = {}) => {
   const decodeRow = makeRowDecoder(rendered, plan, options2);
   return rows.map((row) => decodeRow(row));
 };
-var make3 = (dialect, execute) => ({
+var make3 = (dialect, execute) => withResultContracts({
   dialect,
   execute(plan) {
     return execute(plan);
@@ -7552,23 +7864,81 @@ function driver(dialect, executeOrHandlers) {
         return Stream.unwrap(Effect.map(executeOrHandlers(query), (rows) => Stream.fromIterable(rows)));
       }
       return executeOrHandlers.stream(query);
-    }
+    },
+    ...typeof executeOrHandlers === "function" || executeOrHandlers.executeResult === undefined ? {} : { executeResult: executeOrHandlers.executeResult }
   };
 }
 var fromDriver = (renderer, sqlDriver) => {
-  const executor = {
+  const renderedCache = new WeakMap;
+  const render2 = (plan) => {
+    const cached = renderedCache.get(plan);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const rendered = renderer.render(plan);
+    renderedCache.set(plan, rendered);
+    return rendered;
+  };
+  const executor = withResultContracts({
     dialect: renderer.dialect,
     execute(plan) {
-      const rendered = renderer.render(plan);
+      const rendered = render2(plan);
       return Effect.map(sqlDriver.execute(rendered), (rows) => remapRows(rendered, rows));
     },
+    executeResult(plan) {
+      const rendered = render2(plan);
+      const result = sqlDriver.executeResult ? sqlDriver.executeResult(rendered) : Effect.map(sqlDriver.execute(rendered), (rows) => ({ rows }));
+      return Effect.map(result, ({ rows, ...metadata }) => ({
+        ...metadata,
+        rows: remapRows(rendered, rows)
+      }));
+    },
     stream(plan) {
-      const rendered = renderer.render(plan);
+      const rendered = render2(plan);
       return Stream.mapArray(sqlDriver.stream(rendered), (rows) => remapRows(rendered, rows));
     }
-  };
+  });
   return executor;
 };
+var explainQuery = (query, options2 = {}) => {
+  const analyze = options2.analyze ?? false;
+  const format = options2.format ?? "text";
+  let prefix;
+  switch (query.dialect) {
+    case "postgres":
+      prefix = `explain (${[
+        ...analyze ? ["analyze true"] : [],
+        `format ${format}`
+      ].join(", ")}) `;
+      break;
+    case "mysql":
+      if (analyze && format === "json") {
+        throw new Error("MySQL EXPLAIN ANALYZE cannot be combined with JSON format");
+      }
+      prefix = analyze ? "explain analyze " : format === "json" ? "explain format=json " : "explain ";
+      break;
+    case "sqlite":
+      if (analyze || format === "json") {
+        throw new Error("SQLite EXPLAIN QUERY PLAN does not support analyze or JSON format");
+      }
+      prefix = "explain query plan ";
+      break;
+    default:
+      if (analyze || format === "json") {
+        throw new Error("Portable EXPLAIN only supports text plans without analyze");
+      }
+      prefix = "explain ";
+  }
+  return {
+    ...query,
+    sql: prefix + query.sql,
+    projections: [],
+    [TypeId10]: {
+      row: undefined,
+      dialect: query.dialect
+    }
+  };
+};
 var streamFromSqlClient = (query) => Stream.unwrap(Effect.flatMap(SqlClient.SqlClient, (sql) => Effect.flatMap(Effect.serviceOption(sql.transactionService), Option.match({
   onNone: () => sql.reserve,
   onSome: ([connection]) => Effect.succeed(connection)
@@ -7593,11 +7963,11 @@ __export(exports_table2, {
   foreignKey: () => foreignKey3,
   check: () => check3,
   alias: () => alias2,
-  TypeId: () => TypeId10,
+  TypeId: () => TypeId11,
   OptionsSymbol: () => OptionsSymbol2,
   Class: () => Class2
 });
-var TypeId10 = TypeId7;
+var TypeId11 = TypeId7;
 var OptionsSymbol2 = OptionsSymbol;
 var options2 = options;
 var option2 = option;
@@ -7683,68 +8053,18 @@ var named5 = (name) => (option3) => mapOption(option3, (spec) => ({
   name
 }));
 // src/standard/renderer.ts
-var exports_renderer = {};
-__export(exports_renderer, {
+var exports_renderer2 = {};
+__export(exports_renderer2, {
   make: () => make10
 });
 import { pipeArguments as pipeArguments8 } from "effect/Pipeable";
 
-// src/internal/renderer.ts
-var TypeId11 = Symbol.for("effect-qb/Renderer");
-var projectionPathKey = (path2) => JSON.stringify(path2);
-var formatProjectionPath2 = (path2) => path2.join(".");
-var validateProjectionPathsMatchSelection = (plan, projections) => {
-  const expected = flattenSelection(getAst(plan).select);
-  const expectedPaths = new Set(expected.map((projection) => projectionPathKey(projection.path)));
-  const actualPaths = new Set(projections.map((projection) => projectionPathKey(projection.path)));
-  for (const projection of projections) {
-    if (!expectedPaths.has(projectionPathKey(projection.path))) {
-      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} does not exist in the query selection`);
-    }
-  }
-  for (const projection of expected) {
-    if (!actualPaths.has(projectionPathKey(projection.path))) {
-      throw new Error(`Projection path ${formatProjectionPath2(projection.path)} is missing from rendered projections`);
-    }
-  }
-};
-function makeTrusted(dialect, render2) {
-  return makeRenderer(dialect, render2, false);
-}
-var makeRenderer = (dialect, render2, validate) => {
-  if (typeof render2 !== "function") {
-    throw new Error(`Renderer.make requires an explicit render implementation for dialect: ${dialect}`);
-  }
-  return {
-    dialect,
-    render(plan) {
-      const rendered = render2(plan);
-      const projections = rendered.projections ?? [];
-      if (validate) {
-        validateProjections(projections);
-        validateProjectionPathsMatchSelection(plan, projections);
-      }
-      return {
-        sql: rendered.sql,
-        params: rendered.params ?? [],
-        projections,
-        valueMappings: rendered.valueMappings,
-        dialect,
-        [TypeId11]: {
-          row: undefined,
-          dialect
-        }
-      };
-    }
-  };
-};
-
 // src/internal/sql-expression-renderer.ts
 var renderQueryAst = (ast, state, dialect) => {
   return dialect.renderQueryAst(ast, state, dialect);
 };
-var renderExpression = (expression, state, dialect) => {
-  return dialect.renderExpression(expression, state, dialect);
+var renderExpression = (expression2, state, dialect) => {
+  return dialect.renderExpression(expression2, state, dialect);
 };
 
 // src/internal/dialect.ts
@@ -7757,7 +8077,36 @@ var quoteBacktickIdentifier = (value) => {
 var renderDbTypeName = (value) => value;
 
 // src/internal/dialect-renderers/postgres.ts
-import * as Schema10 from "effect/Schema";
+import * as Schema12 from "effect/Schema";
+
+// src/internal/custom-sql-renderer.ts
+var renderCustomSql = (node, state, dialect, renderExpression2) => node.strings.map((part, index6) => {
+  const value = node.values[index6];
+  if (value === undefined) {
+    return part;
+  }
+  return part + (TypeId in value ? renderExpression2(value, state, dialect) : value.parts.map((segment) => dialect.quoteIdentifier(segment)).join("."));
+}).join("");
+
+// src/internal/window-renderer.ts
+var renderBoundary = (boundary) => {
+  if (boundary === "unboundedPreceding") {
+    return "unbounded preceding";
+  }
+  if (boundary === "currentRow") {
+    return "current row";
+  }
+  if (boundary === "unboundedFollowing") {
+    return "unbounded following";
+  }
+  if ("preceding" in boundary) {
+    return `${boundary.preceding} preceding`;
+  }
+  return `${boundary.following} following`;
+};
+var renderWindowFrame = (frame) => frame.end === undefined ? `${frame.unit} ${renderBoundary(frame.start)}` : `${frame.unit} between ${renderBoundary(frame.start)} and ${renderBoundary(frame.end)}`;
+
+// src/internal/dialect-renderers/postgres.ts
 var renderDbType = (dialect, dbType) => {
   return renderDbTypeName(renderPortableDatatypeDdlType(dialect.name, dbType.kind) ?? dbType.kind);
 };
@@ -7898,11 +8247,11 @@ var renderPostgresDdlLiteral = (value, state, context = {}) => {
   }
   throw new Error("Unsupported postgres DDL literal value");
 };
-var renderDdlExpression = (expression, state, dialect) => {
-  if (isSchemaExpression(expression)) {
-    return render(expression);
+var renderDdlExpression = (expression2, state, dialect) => {
+  if (isSchemaExpression(expression2)) {
+    return render(expression2);
   }
-  return renderExpression2(expression, state, {
+  return renderExpression2(expression2, state, {
     ...dialect,
     renderLiteral: renderPostgresDdlLiteral
   });
@@ -8031,6 +8380,15 @@ var renderBinaryExpression = (functionName, operator, left, right, state, dialec
   const [leftExpression, rightExpression] = expectBinaryExpressions(functionName, left, right);
   return `(${renderExpression2(leftExpression, state, dialect)} ${operator} ${renderExpression2(rightExpression, state, dialect)})`;
 };
+var renderNumericExpression = (expression2, state, dialect) => {
+  const rendered = renderExpression2(expression2, state, dialect);
+  const ast = expression2[TypeId2];
+  return dialect.name === "postgres" && ast.kind === "literal" ? `cast(${rendered} as ${renderCastType(dialect, expression2[TypeId].dbType)})` : rendered;
+};
+var renderNumericBinaryExpression = (functionName, operator, left, right, state, dialect) => {
+  const [leftExpression, rightExpression] = expectBinaryExpressions(functionName, left, right);
+  return `(${renderNumericExpression(leftExpression, state, dialect)} ${operator} ${renderNumericExpression(rightExpression, state, dialect)})`;
+};
 var postgresRangeSubtypeByKind = {
   int4range: "int4",
   int8range: "int8",
@@ -8211,21 +8569,21 @@ var renderPostgresJsonValue = (value, state, dialect) => {
   }
   return value[TypeId].dbType.kind === "jsonb" ? rendered : `cast(${rendered} as jsonb)`;
 };
-var expressionDriverContext = (expression, state, dialect) => ({
+var expressionDriverContext = (expression2, state, dialect) => ({
   dialect: dialect.name,
   valueMappings: state.valueMappings,
-  dbType: expression[TypeId].dbType,
-  runtimeSchema: expression[TypeId].runtimeSchema,
-  driverValueMapping: expression[TypeId].driverValueMapping
+  dbType: expression2[TypeId].dbType,
+  runtimeSchema: expression2[TypeId].runtimeSchema,
+  driverValueMapping: expression2[TypeId].driverValueMapping
 });
-var renderJsonInputExpression = (expression, state, dialect) => renderJsonSelectSql(renderExpression2(expression, state, dialect), expressionDriverContext(expression, state, dialect));
+var renderJsonInputExpression = (expression2, state, dialect) => renderJsonSelectSql(renderExpression2(expression2, state, dialect), expressionDriverContext(expression2, state, dialect));
 var encodeArrayValues = (values2, column2, state, dialect) => values2.map((value) => {
   if (value === null && column2.metadata.nullable) {
     return null;
   }
-  const runtimeSchemaAccepts = column2.schema !== undefined && Schema10.is(column2.schema)(value);
+  const runtimeSchemaAccepts = column2.schema !== undefined && Schema12.is(column2.schema)(value);
   const normalizedValue = runtimeSchemaAccepts ? value : normalizeDbValue(column2.metadata.dbType, value);
-  const encodedValue = column2.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema10.decodeUnknownSync(column2.schema)(normalizedValue);
+  const encodedValue = column2.schema === undefined || runtimeSchemaAccepts ? normalizedValue : Schema12.decodeUnknownSync(column2.schema)(normalizedValue);
   return toDriverValue(encodedValue, {
     dialect: dialect.name,
     valueMappings: state.valueMappings,
@@ -8287,7 +8645,7 @@ var renderFunctionCall = (name, args, state, dialect) => {
   }
   return `${functionName}(${renderedArgs})`;
 };
-var renderJsonExpression = (expression, ast, state, dialect) => {
+var renderJsonExpression = (expression2, ast, state, dialect) => {
   const kind = typeof ast.kind === "string" ? ast.kind : undefined;
   if (!kind) {
     return;
@@ -8295,7 +8653,7 @@ 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" && isJsonExpression2(expression) ? renderPostgresJsonKind(expression) : undefined;
+  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression2(expression2) ? renderPostgresJsonKind(expression2) : undefined;
   const postgresBaseKind = dialect.name === "postgres" && isJsonExpression2(base) ? renderPostgresJsonKind(base) : undefined;
   switch (kind) {
     case "jsonGet":
@@ -8596,7 +8954,7 @@ var renderTransactionClause = (clause, dialect) => {
 var renderSelectionList = (selection, state, dialect) => {
   const flattened = flattenSelection(selection);
   const projections = selectionProjections(selection);
-  const sql = flattened.map(({ expression, alias: alias3 }) => `${renderSelectSql(renderExpression2(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias3)}`).join(", ");
+  const sql = flattened.map(({ expression: expression2, alias: alias3 }) => `${renderSelectSql(renderExpression2(expression2, state, dialect), expressionDriverContext(expression2, state, dialect))} as ${dialect.quoteIdentifier(alias3)}`).join(", ");
   return {
     sql,
     projections
@@ -9028,9 +9386,9 @@ var renderSubqueryExpressionPlan = (plan, state, dialect) => {
   }
   return renderQueryAst2(getAst(plan), state, dialect).sql;
 };
-var renderExpression2 = (expression, state, dialect) => {
-  const rawAst = expression[TypeId2];
-  const jsonSql = renderJsonExpression(expression, rawAst, state, dialect);
+var renderExpression2 = (expression2, state, dialect) => {
+  const rawAst = expression2[TypeId2];
+  const jsonSql = renderJsonExpression(expression2, rawAst, state, dialect);
   if (jsonSql !== undefined) {
     return jsonSql;
   }
@@ -9053,7 +9411,7 @@ var renderExpression2 = (expression, state, dialect) => {
       if (typeof ast.value === "number" && !Number.isFinite(ast.value)) {
         throw new Error("Expected a finite numeric value");
       }
-      return dialect.renderLiteral(ast.value, state, expression[TypeId]);
+      return dialect.renderLiteral(ast.value, state, expression2[TypeId]);
     case "excluded":
       if (state.allowExcluded !== true) {
         throw new Error("excluded(...) is only supported inside insert conflict handlers");
@@ -9065,6 +9423,8 @@ var renderExpression2 = (expression, state, dialect) => {
       return `(${renderExpression2(expectValueExpression("collate", ast.value), state, dialect)} collate ${renderCollation(ast.collation)})`;
     case "function":
       return renderFunctionCall(ast.name, ast.args, state, dialect);
+    case "customSql":
+      return renderCustomSql(ast, state, dialect, renderExpression2);
     case "eq":
       return renderBinaryExpression("eq", "=", ast.left, ast.right, state, dialect);
     case "neq":
@@ -9077,6 +9437,16 @@ var renderExpression2 = (expression, state, dialect) => {
       return renderBinaryExpression("gt", ">", ast.left, ast.right, state, dialect);
     case "gte":
       return renderBinaryExpression("gte", ">=", ast.left, ast.right, state, dialect);
+    case "add":
+      return renderNumericBinaryExpression("add", "+", ast.left, ast.right, state, dialect);
+    case "subtract":
+      return renderNumericBinaryExpression("subtract", "-", ast.left, ast.right, state, dialect);
+    case "multiply":
+      return renderNumericBinaryExpression("multiply", "*", ast.left, ast.right, state, dialect);
+    case "divide":
+      return renderNumericBinaryExpression("divide", "/", ast.left, ast.right, state, dialect);
+    case "modulo":
+      return renderNumericBinaryExpression("modulo", "%", ast.left, ast.right, state, dialect);
     case "like":
       return renderBinaryExpression("like", "like", ast.left, ast.right, state, dialect);
     case "ilike": {
@@ -9170,6 +9540,16 @@ var renderExpression2 = (expression, state, dialect) => {
       return `lower(${renderExpression2(expectValueExpression("lower", ast.value), state, dialect)})`;
     case "count":
       return `count(${renderExpression2(expectValueExpression("count", ast.value), state, dialect)})`;
+    case "sum":
+      return `sum(${renderNumericExpression(expectValueExpression("sum", ast.value), state, dialect)})`;
+    case "avg":
+      return `avg(${renderNumericExpression(expectValueExpression("avg", ast.value), state, dialect)})`;
+    case "abs":
+      return `abs(${renderNumericExpression(expectValueExpression("abs", ast.value), state, dialect)})`;
+    case "round":
+      return `round(${renderNumericExpression(expectValueExpression("round", ast.value), state, dialect)})`;
+    case "negate":
+      return `(-${renderNumericExpression(expectValueExpression("negate", ast.value), state, dialect)})`;
     case "max":
       return `max(${renderExpression2(expectValueExpression("max", ast.value), state, dialect)})`;
     case "min":
@@ -9215,23 +9595,43 @@ var renderExpression2 = (expression, state, dialect) => {
     case "window": {
       const partitionBy = ast.partitionBy;
       const orderBy2 = ast.orderBy;
-      const clauses = [];
-      if (partitionBy.length > 0) {
-        clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
-      }
-      if (orderBy2.length > 0) {
-        clauses.push(`order by ${orderBy2.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
-      }
-      const specification = clauses.join(" ");
+      const renderSpecification = () => {
+        const clauses = [];
+        if (partitionBy.length > 0) {
+          clauses.push(`partition by ${partitionBy.map((value) => renderExpression2(value, state, dialect)).join(", ")}`);
+        }
+        if (orderBy2.length > 0) {
+          clauses.push(`order by ${orderBy2.map((entry) => `${renderExpression2(entry.value, state, dialect)} ${entry.direction}`).join(", ")}`);
+        }
+        if (ast.frame !== undefined) {
+          clauses.push(renderWindowFrame(ast.frame));
+        }
+        return clauses.join(" ");
+      };
       switch (ast.function) {
         case "rowNumber":
-          return `row_number() over (${specification})`;
+          return `row_number() over (${renderSpecification()})`;
         case "rank":
-          return `rank() over (${specification})`;
+          return `rank() over (${renderSpecification()})`;
         case "denseRank":
-          return `dense_rank() over (${specification})`;
+          return `dense_rank() over (${renderSpecification()})`;
         case "over":
-          return `${renderExpression2(ast.value, state, dialect)} over (${specification})`;
+          return `${renderExpression2(ast.value, state, dialect)} over (${renderSpecification()})`;
+        case "lag":
+        case "lead": {
+          const args = [renderExpression2(ast.value, state, dialect)];
+          if (ast.offset !== undefined) {
+            args.push(renderExpression2(ast.offset, state, dialect));
+          }
+          if (ast.defaultValue !== undefined) {
+            args.push(renderExpression2(ast.defaultValue, state, dialect));
+          }
+          return `${ast.function}(${args.join(", ")}) over (${renderSpecification()})`;
+        }
+        case "firstValue":
+          return `first_value(${renderExpression2(ast.value, state, dialect)}) over (${renderSpecification()})`;
+        case "lastValue":
+          return `last_value(${renderExpression2(ast.value, state, dialect)}) over (${renderSpecification()})`;
       }
       break;
     }
@@ -9357,15 +9757,17 @@ var applyCategory2 = applyCategory;
 var merge4 = merge;
 export {
   exports_unique as Unique,
+  type2 as Type,
   exports_table2 as Table,
   exports_scalar as Scalar,
   exports_row_set as RowSet,
-  exports_renderer as Renderer,
+  exports_renderer2 as Renderer,
   exports_query as Query,
   exports_primary_key as PrimaryKey,
   exports_json as Json,
   exports_standard as Index,
   exports_function as Function,
+  exports_fragment as Fragment,
   exports_foreign_key as ForeignKey,
   exports_executor as Executor,
   exports_datatypes as Datatypes,