@crvouga/postgres-mem 1.1.1 → 1.1.2

package/dist/unstable.js

@@ -1441,11 +1441,12 @@ function jsonbCompare(a, b) {
       return assertNever(a);
   }
 }
-function jsonbContains(a, b) {
+function jsonbContains(a, b, opts) {
+  const allowScalarInArray = opts?.allowScalarInArray ?? true;
   if (a.j === "obj" && b.j === "obj") {
     for (const [k, bv] of b.v) {
       const av = a.v.get(k);
-      if (av === void 0 || !jsonbContains(av, bv)) return false;
+      if (av === void 0 || !jsonbContains(av, bv, { allowScalarInArray: false })) return false;
     }
     return true;
   }
@@ -1453,7 +1454,7 @@ function jsonbContains(a, b) {
     for (const bv of b.v) {
       let found = false;
       for (const av of a.v) {
-        if (jsonbContains(av, bv)) {
+        if (jsonbContains(av, bv, opts)) {
           found = true;
           break;
         }
@@ -1462,7 +1463,7 @@ function jsonbContains(a, b) {
     }
     return true;
   }
-  if (a.j === "arr" && b.j !== "arr" && b.j !== "obj") {
+  if (allowScalarInArray && a.j === "arr" && b.j !== "arr" && b.j !== "obj") {
     for (const av of a.v) {
       if (av.j === b.j && jsonbEquals(av, b)) return true;
     }
@@ -3413,6 +3414,14 @@ function unifyTypes(a, b) {
 
 // src/types/compare.ts
 var DEFAULT_COMPARE_CTX = {};
+function expectNumber(a, t) {
+  if (typeof a !== "number") throw pgError("internal", `invalid ${t} datum for comparison`, "XX000");
+  return a;
+}
+function expectBigint(a, t) {
+  if (typeof a !== "bigint") throw pgError("internal", `invalid ${t} datum for comparison`, "XX000");
+  return a;
+}
 function datumCompare(t, a, b, ctx = DEFAULT_COMPARE_CTX) {
   if (a === null || b === null) throw pgError("internal", "datumCompare called with null");
   if (isArrayType(t)) return arrayCompare(t, a, b, ctx);
@@ -3427,7 +3436,7 @@ function datumCompare(t, a, b, ctx = DEFAULT_COMPARE_CTX) {
     case "int4":
     case "oid":
     case "date":
-      return a - b;
+      return expectNumber(a, t) - expectNumber(b, t);
     case "float4":
     case "float8": {
       const fa = a;
@@ -3442,8 +3451,8 @@ function datumCompare(t, a, b, ctx = DEFAULT_COMPARE_CTX) {
     case "timestamp":
     case "timestamptz":
     case "time": {
-      const ba = a;
-      const bb = b;
+      const ba = expectBigint(a, t);
+      const bb = expectBigint(b, t);
       return ba < bb ? -1 : ba > bb ? 1 : 0;
     }
     case "numeric":
@@ -3758,6 +3767,7 @@ function getJsonFunctions() {
   });
   m.set("json_typeof", typeofFn);
   m.set("jsonb_typeof", typeofFn);
+  const jsonpathArg = (ctx, arg) => arg.t === "jsonpath" ? arg.v : argText(ctx, arg);
   m.set("jsonb_path_query_first", (ctx, args) => {
     if (args.length < 2) {
       throw pgError(
@@ -3768,11 +3778,22 @@ function getJsonFunctions() {
     }
     if (args[0].v === null || args[1].v === null) return tv("jsonb", null);
     const doc = jsonArg(ctx, args[0]);
-    const path = args[1].t === "jsonpath" ? args[1].v : argText(ctx, args[1]);
-    const found = jsonpathQueryFirst(doc, path);
+    const found = jsonpathQueryFirst(doc, jsonpathArg(ctx, args[1]));
     if (found === null) return tv("jsonb", null);
     return outJsonb(found);
   });
+  m.set("jsonb_path_exists", (ctx, args) => {
+    if (args.length < 2) {
+      throw pgError(
+        "undefined_function",
+        `function jsonb_path_exists(${args.map((a) => a.t).join(", ")}) does not exist`,
+        "42883"
+      );
+    }
+    if (args[0].v === null || args[1].v === null) return tv("bool", null);
+    const doc = jsonArg(ctx, args[0]);
+    return tv("bool", jsonpathQueryFirst(doc, jsonpathArg(ctx, args[1])) !== null);
+  });
   m.set(
     "json_array_length",
     strict("int4", (ctx, args) => {
@@ -6538,6 +6559,18 @@ function parseQualifiedName(name) {
   parts.push(current);
   return parts.map((p) => p.trim()).filter((p) => p.length > 0);
 }
+function sequenceSessionKey(seq) {
+  return `${seq.schema}\0${seq.name}`;
+}
+function markSessionCurrval(ctx, seq, value) {
+  ctx.state.sequenceCurrval.set(sequenceSessionKey(seq), value);
+}
+function sessionCurrvalDefined(ctx, seq) {
+  return ctx.state.sequenceCurrval.has(sequenceSessionKey(seq));
+}
+function readSessionCurrval(ctx, seq) {
+  return ctx.state.sequenceCurrval.get(sequenceSessionKey(seq));
+}
 function sequenceNextval(ctx, seq) {
   seq = ctx.state.ensureWritableSequence(seq);
   let next;
@@ -6567,6 +6600,7 @@ function sequenceNextval(ctx, seq) {
   }
   seq.lastValue = next;
   seq.isCalled = true;
+  markSessionCurrval(ctx, seq, next);
   ctx.state.lastSequence = { schema: seq.schema, name: seq.name };
   return next;
 }
@@ -6642,14 +6676,14 @@ function getMiscFunctions() {
     "currval",
     strict("int8", (ctx, args) => {
       const seq = findSequenceForCall(ctx, argText(ctx, args[0]));
-      if (!seq.isCalled) {
+      if (!sessionCurrvalDefined(ctx, seq)) {
         throw pgError(
           "object_not_in_prerequisite_state",
           `currval of sequence "${seq.name}" is not yet defined in this session`,
           "55000"
         );
       }
-      return tv("int8", seq.lastValue);
+      return tv("int8", readSessionCurrval(ctx, seq));
     })
   );
   m.set("lastval", (ctx) => {
@@ -6658,10 +6692,10 @@ function getMiscFunctions() {
       throw pgError("object_not_in_prerequisite_state", "lastval is not yet defined in this session", "55000");
     }
     const seq = ctx.state.findSequence([last.schema, last.name]);
-    if (!seq?.isCalled) {
+    if (!seq || !sessionCurrvalDefined(ctx, seq)) {
       throw pgError("object_not_in_prerequisite_state", "lastval is not yet defined in this session", "55000");
     }
-    return tv("int8", seq.lastValue);
+    return tv("int8", readSessionCurrval(ctx, seq));
   });
   m.set(
     "setval",
@@ -6678,6 +6712,7 @@ function getMiscFunctions() {
       }
       seq.lastValue = value;
       seq.isCalled = isCalled;
+      if (isCalled) markSessionCurrval(ctx, seq, value);
       ctx.state.lastSequence = { schema: seq.schema, name: seq.name };
       return tv("int8", value);
     })
@@ -12693,7 +12728,10 @@ var Parser = class {
         this.pos++;
         const operand = this.parseUnary();
         if (operand.type === "number_lit") {
-          return t.value === "-" ? { type: "number_lit", raw: `-${operand.raw}` } : operand;
+          if (t.value === "+") return operand;
+          const raw = operand.raw;
+          if (raw.startsWith("-")) return { type: "number_lit", raw: raw.slice(1) };
+          return { type: "number_lit", raw: `-${raw}` };
         }
         return { type: "unop", op: t.value, operand };
       }
@@ -14392,16 +14430,31 @@ function evalUnary(ctx, op, operand) {
   switch (op) {
     case "-": {
       if (t === "unknown") throw pgError("ambiguous_function", "operator is not unique: - unknown");
-      if (v === null) return tv(t, null);
       if (t === "int2" || t === "int4") {
+        if (v === null) return tv(t, null);
         const neg = -v;
         return tv(t, t === "int2" ? checkInt2(neg) : checkInt4(neg));
       }
-      if (t === "int8") return tv(t, checkInt8(-v));
-      if (t === "float4" || t === "float8") return tv(t, -v);
-      if (t === "numeric") return tv(t, numericNeg(v));
-      if (t === "interval") return tv(t, intervalNeg(v));
-      if (t === "money") return tv(t, -v);
+      if (t === "int8") {
+        if (v === null) return tv(t, null);
+        return tv(t, checkInt8(-v));
+      }
+      if (t === "float4" || t === "float8") {
+        if (v === null) return tv(t, null);
+        return tv(t, -v);
+      }
+      if (t === "numeric") {
+        if (v === null) return tv(t, null);
+        return tv(t, numericNeg(v));
+      }
+      if (t === "interval") {
+        if (v === null) return tv(t, null);
+        return tv(t, intervalNeg(v));
+      }
+      if (t === "money") {
+        if (v === null) return tv(t, null);
+        return tv(t, -v);
+      }
       throw pgError("undefined_function", `operator does not exist: - ${typeDisplayName(t)}`);
     }
     case "+": {
@@ -14649,21 +14702,39 @@ function boolArg(ctx, kind, v) {
   }
   return toBool(ctx, v);
 }
-function isPureLiteral(e) {
-  switch (e.type) {
-    case "number_lit":
-    case "string_lit":
-    case "bool_lit":
-    case "null_lit":
-      return true;
-    case "cast":
-      return isPureLiteral(e.expr);
-    default:
-      return false;
+function evalAsPredicate(ctx, kind, v) {
+  return boolArg(ctx, kind, v) === true;
+}
+function checkBoolExprType(ctx, scope, e, kind) {
+  if (e.type === "binop" && e.op === "and") {
+    boolArg(ctx, "AND", evalExpr(ctx, scope, e.left));
+    boolArg(ctx, "AND", evalExpr(ctx, scope, e.right));
+    return;
+  }
+  if (e.type === "binop" && e.op === "or") {
+    boolArg(ctx, "OR", evalExpr(ctx, scope, e.left));
+    boolArg(ctx, "OR", evalExpr(ctx, scope, e.right));
+    return;
+  }
+  if (e.type === "unop" && e.op === "not") {
+    boolArg(ctx, "NOT", evalExpr(ctx, scope, e.operand));
+    return;
+  }
+  if (e.type === "cast") {
+    checkBoolExprType(ctx, scope, e.expr, kind);
+    return;
+  }
+  if (e.type === "case") {
+    validateSearchedCaseTree(ctx, scope, e);
+    return;
+  }
+  const v = evalExpr(ctx, scope, e);
+  if (v.t !== "bool" && v.t !== "unknown") {
+    throw pgError("datatype_mismatch", `argument of ${kind} must be type boolean, not type ${typeDisplayName(v.t)}`);
   }
 }
 function checkSkippedBoolArg(ctx, scope, kind, e) {
-  if (isPureLiteral(e)) boolArg(ctx, kind, evalExpr(ctx, scope, e));
+  boolArg(ctx, kind, evalExpr(ctx, scope, e));
 }
 function evalBinaryNode(ctx, scope, op, leftE, rightE) {
   if (op === "and") {
@@ -14766,7 +14837,55 @@ function applyDomainChecks(ctx, domainKey, value) {
     }
   }
 }
+function validateSearchedCaseTree(ctx, scope, e) {
+  if (e.operand !== null) return;
+  for (const { when, then } of e.whens) {
+    boolArg(ctx, "CASE/WHEN", evalExpr(ctx, scope, when));
+    validateCaseSubExpr(ctx, scope, then);
+  }
+  if (e.elseExpr !== null) validateCaseSubExpr(ctx, scope, e.elseExpr);
+}
+function validateCaseSubExpr(ctx, scope, e) {
+  switch (e.type) {
+    case "case":
+      validateSearchedCaseTree(ctx, scope, e);
+      return;
+    case "binop":
+      if (e.op === "and") {
+        boolArg(ctx, "AND", evalExpr(ctx, scope, e.left));
+        boolArg(ctx, "AND", evalExpr(ctx, scope, e.right));
+      } else if (e.op === "or") {
+        boolArg(ctx, "OR", evalExpr(ctx, scope, e.left));
+        boolArg(ctx, "OR", evalExpr(ctx, scope, e.right));
+      }
+      validateCaseSubExpr(ctx, scope, e.left);
+      validateCaseSubExpr(ctx, scope, e.right);
+      return;
+    case "unop":
+      if (e.op === "not") {
+        boolArg(ctx, "NOT", evalExpr(ctx, scope, e.operand));
+      }
+      validateCaseSubExpr(ctx, scope, e.operand);
+      return;
+    case "cast":
+    case "collate":
+      validateCaseSubExpr(ctx, scope, e.expr);
+      return;
+    case "func":
+      for (const arg of e.args) validateCaseSubExpr(ctx, scope, arg);
+      return;
+    case "row":
+      for (const item of e.items) validateCaseSubExpr(ctx, scope, item);
+      return;
+    case "array_ctor":
+      for (const item of e.items) validateCaseSubExpr(ctx, scope, item);
+      return;
+    default:
+      return;
+  }
+}
 function evalCase(ctx, scope, e) {
+  validateSearchedCaseTree(ctx, scope, e);
   let chosen = null;
   if (e.operand !== null) {
     const operand = evalExpr(ctx, scope, e.operand);
@@ -14780,7 +14899,8 @@ function evalCase(ctx, scope, e) {
     }
   } else {
     for (const { when, then } of e.whens) {
-      if (toBool(ctx, evalExpr(ctx, scope, when)) === true) {
+      const w = evalExpr(ctx, scope, when);
+      if (boolArg(ctx, "CASE/WHEN", w) === true) {
         chosen = then;
         break;
       }
@@ -16117,7 +16237,14 @@ function makeEvalScope(env, scope, extras) {
       return { type: t === UNKNOWN ? "text" : t, values: rel2.rows.map((r) => r[0] ?? null) };
     },
     aggValue(node) {
-      return extras?.aggMap?.get(node);
+      const map = extras?.aggMap;
+      if (!map) return void 0;
+      const direct = map.get(node);
+      if (direct !== void 0) return direct;
+      for (const [call, value] of map) {
+        if (exprEq(call, node)) return value;
+      }
+      return void 0;
     },
     windowValue(node) {
       if (!node.over) return void 0;
@@ -16138,11 +16265,9 @@ function makeEvalScope(env, scope, extras) {
 function evalScalar(env, scope, e, extras) {
   return evalExpr(env.ctx, makeEvalScope(env, scope, extras), e);
 }
-function evalPredicate(env, scope, e, extras) {
+function evalPredicate(env, scope, e, extras, kind = "WHERE") {
   const v = evalScalar(env, scope, e, extras);
-  if (v.v === null) return false;
-  const b = castTo(env.ctx, v, "bool", {});
-  return b.v === true;
+  return evalAsPredicate(env.ctx, kind, v);
 }
 function resolveUserFunctionForArgs(env, name, args) {
   const candidates = env.ctx.state.findFunctions(name);
@@ -16768,7 +16893,7 @@ function combineJoin(env, kind, left, right, on, using, usingAlias, rangeVars, e
     for (let i = 0; i < left.columns.length; i++) row.push(lrow[i] ?? null);
     for (let i = 0; i < right.columns.length; i++) row.push(rrow[i] ?? null);
     const jscope = new RowScope(columns, row, env.outer, rangeVars);
-    return evalPredicate(env, jscope, on);
+    return evalPredicate(env, jscope, on, void 0, "ON");
   };
   const useHashJoin = kind !== "cross" && hashLeftIdxs.length > 0;
   if (useHashJoin) {
@@ -16883,6 +17008,11 @@ function buildFrom(env, items, where = null) {
   }
   return acc;
 }
+function exprHasAggregateCall(e) {
+  const collector = { aggs: [], windows: [], groupings: [] };
+  collectCalls(e, collector);
+  return collector.aggs.length > 0;
+}
 function collectCalls(e, out) {
   if (!e || typeof e !== "object") return;
   if (e.type === "subquery_expr") return;
@@ -17024,7 +17154,192 @@ function groupDefMatches(def, e, columns) {
   }
   return exprEq(def.expr, e);
 }
-function computeAggregate(env, call, rows) {
+function groupingErrorForColref(parts, columns) {
+  const idx = resolveColIdx(columns, parts);
+  let label;
+  if (idx !== null) {
+    const c = columns[idx];
+    label = c.table ? `${c.table}.${c.name}` : c.name;
+  } else {
+    label = parts.join(".");
+  }
+  throw pgError(
+    "grouping_error",
+    `column "${label}" must appear in the GROUP BY clause or be used in an aggregate function`,
+    "42803"
+  );
+}
+function isGroupingExpr(e, groupDefs, columns) {
+  return groupDefs.some((d) => groupDefMatches(d, e, columns));
+}
+function validateGroupedExpr(e, groupDefs, columns, inAgg) {
+  if (!e || typeof e !== "object") return;
+  if (e.type === "subquery_expr") return;
+  if (!inAgg && isGroupingExpr(e, groupDefs, columns)) return;
+  switch (e.type) {
+    case "null_lit":
+    case "string_lit":
+    case "number_lit":
+    case "bool_lit":
+    case "bitstring_lit":
+    case "param":
+    case "default_expr":
+      return;
+    case "colref":
+      if (!inAgg) {
+        if (resolveColIdx(columns, e.parts) === null) return;
+        groupingErrorForColref(e.parts, columns);
+      }
+      return;
+    case "grouping_func":
+      for (const a of e.args) validateGroupedExpr(a, groupDefs, columns, inAgg);
+      return;
+    case "func": {
+      const name = e.name[e.name.length - 1];
+      if (e.over) {
+        for (const a of e.args) validateGroupedExpr(a, groupDefs, columns, false);
+        if (e.filter) validateGroupedExpr(e.filter, groupDefs, columns, false);
+        for (const p of e.over.partitionBy ?? []) validateGroupedExpr(p, groupDefs, columns, false);
+        for (const ob of e.over.orderBy ?? []) validateGroupedExpr(ob.expr, groupDefs, columns, false);
+        return;
+      }
+      if (isAggregateName(name)) {
+        for (const a of e.args) validateGroupedExpr(a, groupDefs, columns, true);
+        if (e.filter) validateGroupedExpr(e.filter, groupDefs, columns, true);
+        for (const ob of e.orderBy ?? []) validateGroupedExpr(ob.expr, groupDefs, columns, true);
+        return;
+      }
+      for (const a of e.args) validateGroupedExpr(a, groupDefs, columns, inAgg);
+      if (e.filter) validateGroupedExpr(e.filter, groupDefs, columns, inAgg);
+      for (const ob of e.orderBy ?? []) validateGroupedExpr(ob.expr, groupDefs, columns, inAgg);
+      return;
+    }
+    case "binop":
+      validateGroupedExpr(e.left, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.right, groupDefs, columns, inAgg);
+      return;
+    case "unop":
+      validateGroupedExpr(e.operand, groupDefs, columns, inAgg);
+      return;
+    case "cast":
+      validateGroupedExpr(e.expr, groupDefs, columns, inAgg);
+      return;
+    case "collate":
+      validateGroupedExpr(e.expr, groupDefs, columns, inAgg);
+      return;
+    case "case": {
+      if (e.operand) validateGroupedExpr(e.operand, groupDefs, columns, inAgg);
+      for (const w of e.whens) {
+        validateGroupedExpr(w.when, groupDefs, columns, inAgg);
+        validateGroupedExpr(w.then, groupDefs, columns, inAgg);
+      }
+      if (e.elseExpr) validateGroupedExpr(e.elseExpr, groupDefs, columns, inAgg);
+      return;
+    }
+    case "in_expr":
+      validateGroupedExpr(e.left, groupDefs, columns, inAgg);
+      if (e.list) {
+        for (const r of e.list) validateGroupedExpr(r, groupDefs, columns, inAgg);
+      }
+      return;
+    case "between":
+      validateGroupedExpr(e.left, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.low, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.high, groupDefs, columns, inAgg);
+      return;
+    case "is_null":
+    case "bool_test":
+      validateGroupedExpr(e.expr, groupDefs, columns, inAgg);
+      return;
+    case "is_distinct":
+      validateGroupedExpr(e.left, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.right, groupDefs, columns, inAgg);
+      return;
+    case "row":
+      for (const el of e.items) validateGroupedExpr(el, groupDefs, columns, inAgg);
+      return;
+    case "array_ctor":
+      for (const el of e.items) validateGroupedExpr(el, groupDefs, columns, inAgg);
+      return;
+    case "array_query":
+      return;
+    case "subscript":
+      validateGroupedExpr(e.base, groupDefs, columns, inAgg);
+      for (const idx of e.indexes) {
+        if (idx.lower) validateGroupedExpr(idx.lower, groupDefs, columns, inAgg);
+        if (idx.upper) validateGroupedExpr(idx.upper, groupDefs, columns, inAgg);
+      }
+      return;
+    case "field_select":
+      validateGroupedExpr(e.base, groupDefs, columns, inAgg);
+      return;
+    case "at_time_zone":
+      validateGroupedExpr(e.expr, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.zone, groupDefs, columns, inAgg);
+      return;
+    case "like":
+      validateGroupedExpr(e.left, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.pattern, groupDefs, columns, inAgg);
+      if (e.escape) validateGroupedExpr(e.escape, groupDefs, columns, inAgg);
+      return;
+    case "position":
+      validateGroupedExpr(e.needle, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.haystack, groupDefs, columns, inAgg);
+      return;
+    case "substring_sql":
+      validateGroupedExpr(e.source, groupDefs, columns, inAgg);
+      if (e.from) validateGroupedExpr(e.from, groupDefs, columns, inAgg);
+      if (e.forLen) validateGroupedExpr(e.forLen, groupDefs, columns, inAgg);
+      if (e.similar) validateGroupedExpr(e.similar, groupDefs, columns, inAgg);
+      if (e.escape) validateGroupedExpr(e.escape, groupDefs, columns, inAgg);
+      return;
+    case "overlay":
+      validateGroupedExpr(e.source, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.placing, groupDefs, columns, inAgg);
+      validateGroupedExpr(e.from, groupDefs, columns, inAgg);
+      if (e.forLen) validateGroupedExpr(e.forLen, groupDefs, columns, inAgg);
+      return;
+    case "trim":
+      validateGroupedExpr(e.source, groupDefs, columns, inAgg);
+      if (e.chars) validateGroupedExpr(e.chars, groupDefs, columns, inAgg);
+      return;
+    case "extract":
+      validateGroupedExpr(e.source, groupDefs, columns, inAgg);
+      return;
+    default:
+      return;
+  }
+}
+function validateGroupedTargets(targets, groupDefs, columns) {
+  for (const t of targets) {
+    if (t.expr.type === "star") {
+      if (t.expr.table) {
+        const label = t.expr.table[t.expr.table.length - 1];
+        for (const c of columns) {
+          if (c.table === label) {
+            const parts = c.table ? [c.table, c.name] : [c.name];
+            validateGroupedExpr({ type: "colref", parts }, groupDefs, columns, false);
+          }
+        }
+      } else {
+        for (const c of columns) {
+          if (!c.hidden) {
+            const parts = c.table ? [c.table, c.name] : [c.name];
+            validateGroupedExpr({ type: "colref", parts }, groupDefs, columns, false);
+          }
+        }
+      }
+      continue;
+    }
+    validateGroupedExpr(t.expr, groupDefs, columns, false);
+  }
+}
+function validateGroupedQuery(core, groupDefs, columns, orderBy = []) {
+  validateGroupedTargets(core.targets, groupDefs, columns);
+  if (core.having) validateGroupedExpr(core.having, groupDefs, columns, false);
+  for (const ob of orderBy) validateGroupedExpr(ob.expr, groupDefs, columns, false);
+}
+function computeAggregate(env, call, rows, probeScope) {
   const ctx = env.ctx;
   const name = call.name[call.name.length - 1];
   const orderedSet = isOrderedSetAggregate(name);
@@ -17111,6 +17426,17 @@ function computeAggregate(env, call, rows) {
     }
     argTypes.push(t);
   }
+  if (effective.length === 0 && probeScope !== null && argCount > 0) {
+    const scope = makeEvalScope(env, probeScope);
+    for (let i = 0; i < argCount; i++) {
+      if (argTypes[i] !== UNKNOWN) continue;
+      if (call.star) continue;
+      const expr = orderedSet && i >= call.args.length ? orderBy[0].expr : call.args[i] ?? orderBy[0].expr;
+      if (!expr) continue;
+      const v = evalExpr(ctx, scope, expr);
+      argTypes[i] = v.t === UNKNOWN ? "text" : v.t;
+    }
+  }
   const acc = createAggregate(ctx, name, argTypes);
   for (const t of effective) acc.step(t.args);
   return acc.result();
@@ -17415,7 +17741,16 @@ function expandTargets(core, columns) {
   }
   return items;
 }
-function executeCore(env0, core, orderBy) {
+function checkPredicateType(env, columns, rangeVars, e, kind, extras) {
+  const probe = new RowScope(
+    columns,
+    columns.map(() => null),
+    env.outer,
+    rangeVars
+  );
+  checkBoolExprType(env.ctx, makeEvalScope(env, probe, extras), e, kind);
+}
+function executeCore(env0, core, orderBy, opts) {
   const env = env0;
   const ctx = env.ctx;
   const source = buildFrom(env, core.from, core.where);
@@ -17424,6 +17759,7 @@ function executeCore(env0, core, orderBy) {
   const rowScope = (row) => new RowScope(srcCols, row, env.outer, rangeVars);
   let srcRows = source.rel.rows;
   if (core.where) {
+    checkPredicateType(env, srcCols, rangeVars, core.where, "WHERE");
     if (core.from.length === 1) {
       const indexed = tryIndexedFromItem(env, core.from[0], core.where);
       if (indexed !== null) {
@@ -17513,7 +17849,7 @@ function executeCore(env0, core, orderBy) {
         const aggMap = /* @__PURE__ */ new Map();
         const groupScopes = rows.map((r) => rowScope(r));
         for (const agg of collector.aggs) {
-          aggMap.set(agg, computeAggregate(env, agg, groupScopes));
+          aggMap.set(agg, computeAggregate(env, agg, groupScopes, repScope));
         }
         ctxs.push({
           scope: repScope,
@@ -17554,9 +17890,19 @@ function executeCore(env0, core, orderBy) {
       return tv("int4", mask);
     } : void 0
   });
+  if (core.having) {
+    if (ctxs.length > 0) {
+      checkPredicateType(env, srcCols, rangeVars, core.having, "HAVING", extrasFor(ctxs[0]));
+    } else if (!exprHasAggregateCall(core.having)) {
+      checkPredicateType(env, srcCols, rangeVars, core.having, "HAVING");
+    }
+  }
+  if (grouped) {
+    validateGroupedQuery(core, groupDefs, srcCols, orderBy);
+  }
   if (core.having) {
     const having = core.having;
-    ctxs = ctxs.filter((rc) => evalPredicate(env, rc.scope, having, extrasFor(rc)));
+    ctxs = ctxs.filter((rc) => evalPredicate(env, rc.scope, having, extrasFor(rc), "HAVING"));
   }
   const windowMaps = /* @__PURE__ */ new Map();
   if (collector.windows.length > 0) {
@@ -17601,6 +17947,14 @@ function executeCore(env0, core, orderBy) {
     sortSpecs.push(spec);
     orderExprs.push({ item, spec });
   }
+  if (core.distinct && !core.distinct.on && sortSpecs.length > 0 && !opts?.hasLimit) {
+    const used = new Set(sortSpecs.map((s) => s.colIdx));
+    for (let i = 0; i < visibleCount; i++) {
+      if (projItems[i].hidden || used.has(i)) continue;
+      sortSpecs.push({ colIdx: i, dir: "asc", nullsFirst: false });
+      used.add(i);
+    }
+  }
   const distinctOnIdx = [];
   if (core.distinct?.on) {
     for (const e of core.distinct.on) {
@@ -17784,7 +18138,7 @@ function executeSelectStmt(env0, stmt) {
   const env = applyWith(env0, stmt.with);
   let rel2;
   if (stmt.body.type === "select_core") {
-    rel2 = executeCore(env, stmt.body, stmt.orderBy);
+    rel2 = executeCore(env, stmt.body, stmt.orderBy, { hasLimit: stmt.limit !== null });
   } else {
     rel2 = executeBody(env, stmt.body);
     const specs = outputOrderSpecs(env, rel2, stmt.orderBy);
@@ -18002,6 +18356,9 @@ var PlParser = class {
       this.expectSemi();
       return { kind: "for", targets, query, body };
     }
+    if (this.atKw("update") || this.atKw("insert") || this.atKw("delete")) {
+      return { kind: "sql", text: this.parseSqlTextUntilSemi() };
+    }
     const target = [];
     const first = this.next();
     if (first.type !== "ident" && first.type !== "quoted_ident") {
@@ -18019,6 +18376,22 @@ var PlParser = class {
     }
     return { kind: "assign", target, expr: this.parseExprUntilSemi() };
   }
+  parseSqlTextUntilSemi() {
+    const start = this.peek().pos;
+    let depth = 0;
+    for (; ; ) {
+      const t = this.peek();
+      if (t.type === "eof") throw unsupported("plpgsql: unterminated statement");
+      if (t.type === "punct" && t.value === "(") depth++;
+      if (t.type === "punct" && t.value === ")") depth--;
+      if (t.type === "punct" && t.value === ";" && depth === 0) {
+        const text = this.src.slice(start, t.pos).trim();
+        this.pos++;
+        return text;
+      }
+      this.pos++;
+    }
+  }
   parseExprUntilSemi() {
     const start = this.peek().pos;
     let depth = 0;
@@ -18236,6 +18609,12 @@ function runStmt(env, stmt, vars, emit, tableNames) {
       }
       return;
     }
+    case "sql": {
+      const stmts = parse(stmt.text);
+      if (stmts.length !== 1) throw unsupported(`plpgsql SQL statement: ${stmt.text}`);
+      runStatement(env, stmts[0]);
+      return;
+    }
   }
 }
 function bindArgs(env, fn, args) {
@@ -18416,6 +18795,12 @@ function runTriggerBody(env, table, stmts, vars) {
         }
         break;
       }
+      case "sql": {
+        const stmts2 = parse(stmt.text);
+        if (stmts2.length !== 1) throw unsupported(`trigger body SQL: ${stmt.text}`);
+        runStatement(env, stmts2[0]);
+        break;
+      }
       default:
         throw unsupported(`trigger body: ${stmt.kind}`);
     }
@@ -18666,6 +19051,8 @@ var DatabaseState = class _DatabaseState {
   inTransaction = false;
   /** most recent sequence touched by nextval/setval, for lastval() */
   lastSequence = null;
+  /** Session currval per sequence; absent entry means currval is undefined. */
+  sequenceCurrval = /* @__PURE__ */ new Map();
   constructor(prng, clock) {
     this.prng = prng;
     this.clock = clock;
@@ -18854,6 +19241,7 @@ var DatabaseState = class _DatabaseState {
     s.changes = this.changes;
     s.inTransaction = this.inTransaction;
     s.lastSequence = this.lastSequence ? { ...this.lastSequence } : null;
+    s.sequenceCurrval = new Map(this.sequenceCurrval);
     s.oidCounter = this.oidCounter;
     return s;
   }
@@ -18868,6 +19256,7 @@ var DatabaseState = class _DatabaseState {
     s.changes = this.changes;
     s.inTransaction = this.inTransaction;
     s.lastSequence = this.lastSequence ? { ...this.lastSequence } : null;
+    s.sequenceCurrval = new Map(this.sequenceCurrval);
     s.oidCounter = this.oidCounter;
     return s;
   }
@@ -18938,6 +19327,7 @@ var DatabaseState = class _DatabaseState {
     this.prepared = other.prepared;
     this.changes = other.changes;
     this.lastSequence = other.lastSequence;
+    this.sequenceCurrval = other.sequenceCurrval;
     this.oidCounter = other.oidCounter;
   }
   /** @internal Snapshot codec access to the oid allocator. */
@@ -20279,6 +20669,22 @@ function executeTruncate(env, stmt) {
 }
 
 // src/executor/dml.ts
+function withStatementRollback(env, fn) {
+  if (env.ctx.state.inTransaction) return fn();
+  const state = env.ctx.state;
+  state.freezeShared();
+  const snap = state.cloneShallow();
+  const prngSnap = state.prng.getState();
+  try {
+    return fn();
+  } catch (e) {
+    state.restoreFrom(snap);
+    state.prng.setState(prngSnap);
+    throw e;
+  } finally {
+    state.thawShared();
+  }
+}
 function requireTargetTable(env, parts, verb) {
   const state = env.ctx.state;
   const table = state.findTable(parts);
@@ -20479,84 +20885,86 @@ function executeInsert(env0, stmt) {
   const sourceRows = insertSourceRows(env, stmt, colIdxs);
   const insertedRows = [];
   let insertedCount = 0;
-  for (const srcRow of sourceRows) {
-    const row = table.columns.map(() => null);
-    const provided = /* @__PURE__ */ new Set();
-    for (let k = 0; k < srcRow.length; k++) {
-      const ci = colIdxs[k];
-      const col = table.columns[ci];
-      const cell = srcRow[k];
-      if (cell === DEFAULT_MARKER) {
-        row[ci] = columnDefault(env, table, col);
+  return withStatementRollback(env, () => {
+    for (const srcRow of sourceRows) {
+      const row = table.columns.map(() => null);
+      const provided = /* @__PURE__ */ new Set();
+      for (let k = 0; k < srcRow.length; k++) {
+        const ci = colIdxs[k];
+        const col = table.columns[ci];
+        const cell = srcRow[k];
+        if (cell === DEFAULT_MARKER) {
+          row[ci] = columnDefault(env, table, col);
+          provided.add(ci);
+          continue;
+        }
+        if (col.identity?.always && stmt.overriding !== "system") {
+          throw pgError("generated_always", `cannot insert a non-DEFAULT value into column "${col.name}"`, "428C9");
+        }
+        row[ci] = coerceToColumn(env, cell, col);
         provided.add(ci);
-        continue;
-      }
-      if (col.identity?.always && stmt.overriding !== "system") {
-        throw pgError("generated_always", `cannot insert a non-DEFAULT value into column "${col.name}"`, "428C9");
       }
-      row[ci] = coerceToColumn(env, cell, col);
-      provided.add(ci);
-    }
-    for (let i = 0; i < table.columns.length; i++) {
-      if (provided.has(i)) continue;
-      const col = table.columns[i];
-      if (col.generated) continue;
-      row[i] = columnDefault(env, table, col);
-    }
-    const fired = fireRowTriggers(env, table, "before", "insert", null, row);
-    if (fired.row === null) continue;
-    const newRow = fired.row;
-    computeGeneratedColumns(env, table, newRow);
-    if (stmt.onConflict) {
-      const arbiters = resolveArbiters(env, table, stmt.onConflict);
-      let conflictIdx = null;
-      let conflictWhereOk = true;
-      for (const a of arbiters) {
-        if ("columns" in (stmt.onConflict.target ?? {}) && stmt.onConflict.target && "columns" in stmt.onConflict.target && stmt.onConflict.target.where) {
-          const scope = tableRowScope(env, table, label, newRow);
-          conflictWhereOk = evalPredicate(env, scope, stmt.onConflict.target.where);
-        }
-        const idx = findConflict(env, table, a.spec, newRow);
-        if (idx !== null) {
-          conflictIdx = idx;
-          break;
+      for (let i = 0; i < table.columns.length; i++) {
+        if (provided.has(i)) continue;
+        const col = table.columns[i];
+        if (col.generated) continue;
+        row[i] = columnDefault(env, table, col);
+      }
+      const fired = fireRowTriggers(env, table, "before", "insert", null, row);
+      if (fired.row === null) continue;
+      const newRow = fired.row;
+      computeGeneratedColumns(env, table, newRow);
+      if (stmt.onConflict) {
+        const arbiters = resolveArbiters(env, table, stmt.onConflict);
+        let conflictIdx = null;
+        let conflictWhereOk = true;
+        for (const a of arbiters) {
+          if ("columns" in (stmt.onConflict.target ?? {}) && stmt.onConflict.target && "columns" in stmt.onConflict.target && stmt.onConflict.target.where) {
+            const scope = tableRowScope(env, table, label, newRow);
+            conflictWhereOk = evalPredicate(env, scope, stmt.onConflict.target.where);
+          }
+          const idx = findConflict(env, table, a.spec, newRow);
+          if (idx !== null) {
+            conflictIdx = idx;
+            break;
+          }
         }
-      }
-      if (conflictIdx !== null && conflictWhereOk) {
-        if (stmt.onConflict.action === "nothing") continue;
-        const did = applyOnConflictUpdate(
-          env,
-          table,
-          label,
-          conflictIdx,
-          newRow,
-          stmt.onConflict.action.sets,
-          stmt.onConflict.action.where
-        );
-        if (did) {
-          insertedCount++;
-          insertedRows.push(rows[conflictIdx]);
-          fireRowTriggers(env, table, "after", "update", null, rows[conflictIdx]);
+        if (conflictIdx !== null && conflictWhereOk) {
+          if (stmt.onConflict.action === "nothing") continue;
+          const did = applyOnConflictUpdate(
+            env,
+            table,
+            label,
+            conflictIdx,
+            newRow,
+            stmt.onConflict.action.sets,
+            stmt.onConflict.action.where
+          );
+          if (did) {
+            insertedCount++;
+            insertedRows.push(rows[conflictIdx]);
+            fireRowTriggers(env, table, "after", "update", null, rows[conflictIdx]);
+          }
+          continue;
         }
-        continue;
       }
+      checkNotNull(env, table, newRow);
+      checkChecks(env, table, newRow);
+      checkUnique(env, table, newRow, rows.length);
+      checkForeignKeys(env, table, newRow);
+      rows.push(newRow);
+      indexInsertRow(env, table, rows.length - 1, newRow);
+      insertedCount++;
+      insertedRows.push(newRow);
+      fireRowTriggers(env, table, "after", "insert", null, newRow);
     }
-    checkNotNull(env, table, newRow);
-    checkChecks(env, table, newRow);
-    checkUnique(env, table, newRow, rows.length);
-    checkForeignKeys(env, table, newRow);
-    rows.push(newRow);
-    indexInsertRow(env, table, rows.length - 1, newRow);
-    insertedCount++;
-    insertedRows.push(newRow);
-    fireRowTriggers(env, table, "after", "insert", null, newRow);
-  }
-  env.ctx.state.changes = insertedCount;
-  if (stmt.returning) {
-    const res = evalReturning(env, table, label, stmt.returning, insertedRows, "INSERT");
-    return { ...res, rowCount: insertedCount };
-  }
-  return commandResult("INSERT", insertedCount);
+    env.ctx.state.changes = insertedCount;
+    if (stmt.returning) {
+      const res = evalReturning(env, table, label, stmt.returning, insertedRows, "INSERT");
+      return { ...res, rowCount: insertedCount };
+    }
+    return commandResult("INSERT", insertedCount);
+  });
 }
 function applyUpdateSets(env, table, sets, scope, row) {
   for (const set of sets) {