tempest-db-js 0.7.0 → 0.9.0

package/dist/migrations/index.cjs

@@ -3,11 +3,145 @@
 var module$1 = require('module');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/conditions.ts
+var CONDITION = /* @__PURE__ */ Symbol.for("tempest-db-js.condition");
+function wrap(node) {
+  return { [CONDITION]: true, node };
+}
+function toExprNode(operand) {
+  return isExpression(operand) ? operand.node : { kind: "value", value: operand };
+}
+function assertValueOperands(op, operands) {
+  if (operands.some(isExpression)) {
+    throw new Error(
+      `The "${op}" operator binds its operands, so it takes values, not expressions.`
+    );
+  }
+}
+function isExpression(value) {
+  return value instanceof Expression;
+}
+var Expression = class {
+  constructor(node) {
+    this.node = node;
+  }
+  node;
+  /** Compare this expression against another expression or a bound value. */
+  compare(op, operand) {
+    return wrap({ kind: "compare", left: this.node, op, right: toExprNode(operand) });
+  }
+  /** `=` (or `IS NULL` for a null value). */
+  eq(operand) {
+    return this.compare("eq", operand);
+  }
+  /** `<>` (or `IS NOT NULL` for a null value). */
+  ne(operand) {
+    return this.compare("ne", operand);
+  }
+  /** `>`. */
+  gt(operand) {
+    return this.compare("gt", operand);
+  }
+  /** `>=`. */
+  gte(operand) {
+    return this.compare("gte", operand);
+  }
+  /** `<`. */
+  lt(operand) {
+    return this.compare("lt", operand);
+  }
+  /** `<=`. */
+  lte(operand) {
+    return this.compare("lte", operand);
+  }
+  /** `LIKE` — `%` and `_` in the operand are wildcards. */
+  like(pattern) {
+    return this.compare("like", pattern);
+  }
+  /** `ILIKE` — case-insensitive **pattern** matching, wildcards included. */
+  ilike(pattern) {
+    return this.compare("ilike", pattern);
+  }
+  /** Case-insensitive equality (`lower(a) = lower(b)`), with no wildcards. */
+  ieq(operand) {
+    return this.compare("ieq", operand);
+  }
+  /**
+   * `IN (...)` over a list of values.
+   *
+   * @param values The values to test against.
+   * @returns The condition.
+   * @throws Error When an entry is an {@link Expression} — a list operand is
+   *   bound, so an expression there would be serialized as a parameter instead of
+   *   rendered as SQL.
+   */
+  in(values) {
+    assertValueOperands("in", values);
+    return this.compare("in", values);
+  }
+  /**
+   * `NOT IN (...)` over a list of values.
+   *
+   * @param values The values to exclude.
+   * @returns The condition.
+   * @throws Error When an entry is an {@link Expression} (see {@link Expression.in}).
+   */
+  notIn(values) {
+    assertValueOperands("notIn", values);
+    return this.compare("notIn", values);
+  }
+  /**
+   * `BETWEEN lo AND hi` (inclusive).
+   *
+   * @param lo The lower bound.
+   * @param hi The upper bound.
+   * @returns The condition.
+   * @throws Error When a bound is an {@link Expression} (see {@link Expression.in}).
+   */
+  between(lo, hi) {
+    assertValueOperands("between", [lo, hi]);
+    return this.compare("between", [lo, hi]);
+  }
+  /** `IS NULL` (true) / `IS NOT NULL` (false). */
+  isNull(value = true) {
+    return this.compare("isNull", value);
+  }
+};
+
+// src/query.ts
+function isSubquery(value) {
+  return typeof value === "object" && value !== null && value.node?.kind === "select";
+}
+var OPERATORS = [
+  "eq",
+  "ne",
+  "gt",
+  "gte",
+  "lt",
+  "lte",
+  "like",
+  "ilike",
+  "ieq",
+  "iContains",
+  "in",
+  "notIn",
+  "between",
+  "isNull",
+  "contains",
+  "containedBy",
+  "overlaps"
+];
+
 // src/expressions.ts
+function renderExcluded(column, bare, dialect) {
+  return dialect === "mysql" ? `VALUES(${bare})` : `excluded.${column}`;
+}
 function renderPortableToken(token, dialect) {
   switch (token) {
     case "now":
-      return dialect === "postgresql" ? "now()" : "CURRENT_TIMESTAMP";
+      if (dialect === "postgresql") return "now()";
+      if (dialect === "sqlite") return "strftime('%Y-%m-%dT%H:%M:%fZ', 'now')";
+      return "CURRENT_TIMESTAMP";
     case "current_date":
       return "CURRENT_DATE";
     case "current_time":
@@ -18,6 +152,1264 @@ function renderPortableToken(token, dialect) {
       return "(lower(hex(randomblob(16))))";
   }
 }
+
+// src/search.ts
+function escapeLike(value) {
+  return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+
+// src/dialect.ts
+var OPERATOR_SET = new Set(OPERATORS);
+var MULTI_VALUE_OPERATORS = /* @__PURE__ */ new Set(["in", "notIn", "between"]);
+function encodeOperand(op, operand, encode) {
+  if (op === "isNull") return operand;
+  if (MULTI_VALUE_OPERATORS.has(op)) {
+    return Array.isArray(operand) ? operand.map(encode) : operand;
+  }
+  return encode(operand);
+}
+function codecEncoder(codecs) {
+  if (!codecs) return (_key, value) => value;
+  return (key, value) => {
+    const codec = codecs[key];
+    return codec ? codec.toDb(value) : value;
+  };
+}
+function isOperatorObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || value instanceof Date || value instanceof Uint8Array) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  return keys.length > 0 && keys.every((k) => OPERATOR_SET.has(k));
+}
+var Params = class {
+  constructor(placeholder2) {
+    this.placeholder = placeholder2;
+  }
+  placeholder;
+  values = [];
+  bind(value) {
+    this.values.push(value);
+    return this.placeholder(this.values.length);
+  }
+};
+var LiteralParams = class extends Params {
+  constructor() {
+    super(() => "");
+  }
+  bind(value) {
+    if (value === null || value === void 0) return "NULL";
+    if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+    if (typeof value === "number" || typeof value === "bigint") return String(value);
+    if (value instanceof Date) return `'${value.toISOString()}'`;
+    return `'${String(value).replace(/'/g, "''")}'`;
+  }
+};
+function insertColumns(rows) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (seen.has(key)) continue;
+      seen.add(key);
+      columns.push(key);
+    }
+  }
+  return columns;
+}
+function insertHasExpression(node) {
+  for (const row of node.values) {
+    for (const value of Object.values(row)) {
+      if (isSqlExpression(value)) return true;
+    }
+  }
+  const update = node.onConflict?.update;
+  if (update && update !== "nothing") {
+    for (const value of Object.values(update)) {
+      if (isSqlExpression(value)) return true;
+    }
+  }
+  return false;
+}
+var BaseDialect = class _BaseDialect {
+  /**
+   * INSERT SQL templates keyed by structure (dialect|table|columns|rowCount|
+   * returning). Shared across dialect instances — the key namespaces by dialect
+   * name, and the placeholder text is dialect-specific but structure-determined.
+   */
+  static insertTemplates = /* @__PURE__ */ new Map();
+  /** Quoted-identifier cache (see {@link quoteId}). Shared across dialects. */
+  static quotedIds = /* @__PURE__ */ new Map();
+  /**
+   * Render a case-insensitive LIKE whose pattern carries escaped wildcards.
+   *
+   * The `ESCAPE` clause is not decoration: PostgreSQL treats `\` as the escape
+   * character by default, **SQLite has none at all** until one is declared, so
+   * without this the escaping done on our side would be meaningless there.
+   *
+   * @param column The rendered column.
+   * @param param The bound pattern.
+   * @returns The rendered comparison.
+   */
+  ilikeEscaped(column, param) {
+    return `${this.ilike(column, param)} ESCAPE '\\'`;
+  }
+  /**
+   * Validate a subquery operand before it is rendered, for dialects that restrict
+   * what an `IN (SELECT ...)` may contain. The default accepts everything.
+   *
+   * @param _node The subquery's AST.
+   * @throws Error When the dialect cannot execute this subquery.
+   */
+  checkSubquery(_node) {
+  }
+  /**
+   * The SQL operator for an array containment/overlap test.
+   *
+   * Only PostgreSQL has native arrays; the other dialects throw rather than
+   * emitting an operator that means something else there.
+   *
+   * @param op The array operator name.
+   * @returns The SQL operator text.
+   * @throws Error On a dialect without native array support.
+   */
+  arrayOperator(op) {
+    throw new Error(
+      `The "${op}" operator needs native array support, which ${this.name} does not have.`
+    );
+  }
+  /**
+   * Quote an identifier (column/table) for the active dialect.
+   *
+   * Memoized: identifiers form a small, stable set (column/table names), but this
+   * runs for every identifier on every compile. Caching the quoted form removes a
+   * regex-replace + string allocation from the hot path. The standard double-quote
+   * form is identical across both dialects, so one shared cache is correct.
+   */
+  quoteId(name) {
+    const cached = _BaseDialect.quotedIds.get(name);
+    if (cached !== void 0) return cached;
+    const quoted = `"${name.replace(/"/g, '""')}"`;
+    _BaseDialect.quotedIds.set(name, quoted);
+    return quoted;
+  }
+  /** Compile any node to `{ sql, params }`. */
+  compile(node) {
+    const params = new Params((i) => this.placeholder(i));
+    let sql;
+    switch (node.kind) {
+      case "select":
+        sql = this.compileSelect(node, params);
+        break;
+      case "insert":
+        sql = this.compileInsert(node, params);
+        break;
+      case "update":
+        sql = this.compileUpdate(node, params);
+        break;
+      case "delete":
+        sql = this.compileDelete(node, params);
+        break;
+      case "join_select":
+        sql = this.compileJoin(node, params);
+        break;
+      case "set_op":
+        sql = this.compileSetOp(node, params);
+        break;
+    }
+    return { sql, params: params.values };
+  }
+  /**
+   * Render a condition as schema SQL, with values inlined.
+   *
+   * Same compiler as a `WHERE`, different parameter strategy — so a `CHECK` and
+   * the query language cannot drift apart in what they mean.
+   *
+   * @param node The condition.
+   * @param params A {@link LiteralParams}.
+   * @returns The rendered predicate.
+   */
+  renderConditionLiteral(node, params) {
+    return this.compileCondition(node, params, (key) => this.columnId(key, void 0));
+  }
+  /**
+   * Render the `WITH` clause of a statement.
+   *
+   * `RECURSIVE` is a property of the **clause**, not of an entry: one recursive
+   * entry makes the whole `WITH` recursive, which is what the SQL standard says
+   * and what PostgreSQL and SQLite both implement.
+   *
+   * @param entries The `WITH` entries, if any.
+   * @param params The parameter collector.
+   * @returns The clause with a trailing space, or an empty string.
+   */
+  compileWith(entries, params) {
+    if (!entries || entries.length === 0) return "";
+    const recursive = entries.some((entry) => entry.recursive) ? "RECURSIVE " : "";
+    const rendered = entries.map((entry) => {
+      const body = entry.body.kind === "set_op" ? this.compileSetOp(entry.body, params) : this.compileSelect(entry.body, params);
+      const hint = entry.materialized === null ? "" : entry.materialized ? " MATERIALIZED" : " NOT MATERIALIZED";
+      return `${this.quoteId(entry.name)} AS${hint} (${body})`;
+    });
+    return `WITH ${recursive}${rendered.join(", ")} `;
+  }
+  /**
+   * The `EXPLAIN` prefix for this dialect.
+   *
+   * @param analyze Whether to measure by actually running the statement.
+   * @returns The prefix to put in front of the statement.
+   * @throws Error When the dialect cannot do what was asked.
+   */
+  explainPrefix(analyze) {
+    return analyze ? "EXPLAIN (FORMAT JSON, ANALYZE)" : "EXPLAIN (FORMAT JSON)";
+  }
+  /**
+   * The SQL keyword for a set operation.
+   *
+   * @param op The operator.
+   * @returns The keyword.
+   * @throws Error On a dialect that does not implement it.
+   */
+  setOperator(op) {
+    switch (op) {
+      case "union":
+        return "UNION";
+      case "unionAll":
+        return "UNION ALL";
+      case "intersect":
+        return "INTERSECT";
+      case "except":
+        return "EXCEPT";
+    }
+  }
+  /**
+   * Compile a set operation.
+   *
+   * A branch carrying its own `ORDER BY`/`LIMIT` is parenthesized: without the
+   * parentheses those clauses bind to the **combined** result, which is a
+   * different query and a classic source of silently wrong output.
+   *
+   * @param node The set-operation node.
+   * @param params The parameter collector.
+   * @returns The rendered statement.
+   */
+  compileSetOp(node, params) {
+    const keyword = ` ${this.setOperator(node.op)} `;
+    const branches = node.branches.map((branch) => {
+      const sql2 = branch.kind === "join_select" ? this.compileJoin(branch, params) : this.compileSelect(branch, params);
+      const scoped = branch.orderBy.length > 0 || branch.limit !== void 0;
+      return scoped ? `(${sql2})` : sql2;
+    });
+    let sql = branches.join(keyword);
+    if (node.orderBy.length > 0) {
+      const terms = node.orderBy.map((t) => {
+        const id = typeof t.column === "string" ? this.quoteId(t.column) : this.renderExpr(t.column, params, (k) => this.quoteId(k));
+        return `${id} ${t.direction === "desc" ? "DESC" : "ASC"}`;
+      }).join(", ");
+      sql += ` ORDER BY ${terms}`;
+    }
+    if (node.limit !== void 0) sql += ` LIMIT ${params.bind(node.limit)}`;
+    if (node.offset !== void 0) sql += ` OFFSET ${params.bind(node.offset)}`;
+    return sql;
+  }
+  /**
+   * Render a qualified `alias.column` ref as `"alias"."column"`, translating the
+   * property name to the real column name for that alias's model.
+   *
+   * @param ref The `alias.property` reference (a bare name is left unqualified).
+   * @param names The node's per-alias name maps, if any source renames columns.
+   * @returns The quoted, qualified identifier.
+   */
+  qualify(ref, names) {
+    const dot = ref.indexOf(".");
+    if (dot === -1) return this.quoteId(ref);
+    const alias = ref.slice(0, dot);
+    const prop = ref.slice(dot + 1);
+    return `${this.quoteId(alias)}.${this.columnId(prop, names?.[alias])}`;
+  }
+  /**
+   * Quote a column identifier, translating the model property name to the real
+   * database column name first.
+   *
+   * `names` is `undefined` for a model that renames nothing — the overwhelmingly
+   * common case — so this stays a single lookup plus the memoized quote.
+   *
+   * @param prop The model property name as written in the builder.
+   * @param names The node's property → column map, if any.
+   * @returns The quoted database identifier.
+   */
+  columnId(prop, names) {
+    const mapped = names?.[prop];
+    if (mapped !== void 0) return this.quoteId(mapped);
+    const dot = prop.indexOf(".");
+    if (dot > 0 && dot < prop.length - 1) {
+      return `${this.quoteId(prop.slice(0, dot))}.${this.quoteId(prop.slice(dot + 1))}`;
+    }
+    return this.quoteId(prop);
+  }
+  /**
+   * Render a {@link SqlExpression} inline, binding the parameters it carries.
+   *
+   * This is what keeps `set({ attempts: sql.raw("attempts + 1") })` an expression
+   * instead of a bound object: the fragment goes into the statement text, and
+   * only a `sql.expr` template's interpolations become parameters.
+   *
+   * @param expr The branded expression.
+   * @param params The parameter collector for the statement being compiled.
+   * @returns The SQL text of the expression.
+   */
+  renderExpression(expr, params) {
+    const token = expr.expression;
+    if (typeof token === "string") return renderPortableToken(token, this.name);
+    if ("raw" in token) return token.raw;
+    if ("excluded" in token) {
+      return renderExcluded(this.quoteId(token.excluded), token.excluded, this.name);
+    }
+    const parts = token.parts;
+    let sql = parts[0] ?? "";
+    for (let i = 1; i < parts.length; i++) {
+      sql += `${params.bind(expr.params[i - 1])}${parts[i]}`;
+    }
+    return sql;
+  }
+  /** Render one write value: a SQL expression inline, anything else as a parameter. */
+  renderValue(value, params) {
+    if (isSqlExpression(value)) return this.renderExpression(value, params);
+    if (isExpression(value)) {
+      return this.renderExpr(value.node, params, (k) => this.columnId(k, void 0));
+    }
+    return params.bind(value);
+  }
+  /**
+   * The statements that open a transaction with the requested characteristics.
+   *
+   * Returned as a list because the dialects disagree on shape: PostgreSQL takes
+   * everything on the `BEGIN` itself, MySQL needs a separate `SET TRANSACTION`
+   * before it, and SQLite has no syntax at all.
+   *
+   * @param options The requested isolation level and read-only flag.
+   * @returns The statements to run, in order.
+   * @throws Error When the dialect cannot honor what was asked.
+   */
+  beginStatements(options) {
+    const parts = ["BEGIN"];
+    if (options?.isolation)
+      parts.push(`ISOLATION LEVEL ${options.isolation.toUpperCase()}`);
+    if (options?.readOnly) parts.push("READ ONLY");
+    return [parts.join(" ")];
+  }
+  /**
+   * Render a row-level locking clause (`FOR UPDATE ...`).
+   *
+   * Standard on PostgreSQL and MySQL 8.0+; SQLite overrides it to throw.
+   *
+   * @param lock The locking clause from the node.
+   * @returns The SQL text, leading space included.
+   */
+  renderLock(lock) {
+    const strength = lock.strength === "update" ? "FOR UPDATE" : "FOR SHARE";
+    const of = lock.of.length > 0 ? ` OF ${lock.of.map((t) => this.quoteId(t)).join(", ")}` : "";
+    const wait = lock.wait === "skipLocked" ? " SKIP LOCKED" : lock.wait === "noWait" ? " NOWAIT" : "";
+    return ` ${strength}${of}${wait}`;
+  }
+  // ---- statements -------------------------------------------------------
+  /**
+   * Compile a SELECT.
+   *
+   * Two alias rules differ between clauses and are handled here: PostgreSQL does
+   * NOT accept a `SELECT` alias in `HAVING`, so an aggregate key is re-emitted as
+   * its expression (`COUNT(*) > $1`), a form every dialect accepts; `ORDER BY`,
+   * by contrast, accepts the output alias everywhere, so it is emitted as
+   * written.
+   *
+   * @param node The select AST.
+   * @param params The parameter collector.
+   * @returns The SQL text.
+   */
+  compileSelect(node, params) {
+    const names = node.names;
+    let cols;
+    if (node.aggregates.length > 0) {
+      const groupSel = node.groupBy.map((c) => this.columnId(c, names));
+      const aggSel = node.aggregates.map((a) => {
+        const inner = this.aggregateOperand(a, params, names);
+        return `${a.fn.toUpperCase()}(${inner}) AS ${this.quoteId(a.alias)}`;
+      });
+      cols = [...groupSel, ...aggSel].join(", ");
+    } else {
+      cols = node.columns === "*" ? "*" : node.columns.map((c) => this.columnId(c, names)).join(", ");
+    }
+    const computed = Object.entries(node.computed ?? {}).map(
+      ([alias, expr]) => `${this.renderExpr(expr, params, (k) => this.columnId(k, names))} AS ${this.quoteId(alias)}`
+    );
+    if (computed.length > 0) cols = [cols, ...computed].join(", ");
+    const from = node.alias ? `${this.quoteId(node.table)} AS ${this.quoteId(node.alias)}` : this.quoteId(node.table);
+    let sql = `${this.compileWith(node.with, params)}SELECT ${node.distinct ? "DISTINCT " : ""}${cols} FROM ${from}`;
+    const where = this.compileCondition(
+      node.where,
+      params,
+      (k) => this.columnId(k, names),
+      codecEncoder(node.codecs)
+    );
+    if (where) sql += ` WHERE ${where}`;
+    if (node.groupBy.length > 0) {
+      sql += ` GROUP BY ${node.groupBy.map((c) => this.columnId(c, names)).join(", ")}`;
+    }
+    const aggByAlias = new Map(node.aggregates.map((a) => [a.alias, a]));
+    if (node.having) {
+      const having = this.compileCondition(node.having, params, (key) => {
+        const agg = aggByAlias.get(key);
+        if (!agg) return this.columnId(key, names);
+        const inner = this.aggregateOperand(agg, params, names);
+        return `${agg.fn.toUpperCase()}(${inner})`;
+      });
+      if (having) sql += ` HAVING ${having}`;
+    }
+    if (node.orderBy.length > 0) {
+      const terms = node.orderBy.map((t) => {
+        const id = typeof t.column !== "string" ? this.renderExpr(t.column, params, (k) => this.columnId(k, names)) : aggByAlias.has(t.column) ? this.quoteId(t.column) : this.columnId(t.column, names);
+        return `${id} ${t.direction === "desc" ? "DESC" : "ASC"}`;
+      }).join(", ");
+      sql += ` ORDER BY ${terms}`;
+    }
+    if (node.limit !== void 0) sql += ` LIMIT ${params.bind(node.limit)}`;
+    if (node.offset !== void 0) sql += ` OFFSET ${params.bind(node.offset)}`;
+    if (node.lock) {
+      if (node.distinct || node.groupBy.length > 0 || node.aggregates.length > 0) {
+        throw new Error(
+          "FOR UPDATE / FOR SHARE cannot be combined with DISTINCT or an aggregate query \u2014 lock the underlying rows in a separate SELECT."
+        );
+      }
+      sql += this.renderLock(node.lock);
+    }
+    return sql;
+  }
+  /**
+   * Compile an INSERT.
+   *
+   * Takes the cached fast path only when the statement text is a pure function of
+   * its structure. A SQL expression among the values, or a conflict predicate,
+   * makes the text depend on the values themselves — those compile uncached, in
+   * SQL order, so placeholder positions stay correct.
+   */
+  compileInsert(node, params) {
+    if (node.fromSelect) {
+      const target = node.fromSelect.columns.map((c) => this.columnId(c, node.names)).join(", ");
+      const source = node.fromSelect.select;
+      const query = source.kind === "join_select" ? this.compileJoin(source, params) : source.kind === "set_op" ? this.compileSetOp(source, params) : this.compileSelect(source, params);
+      const returning = this.compileReturning(node.returning, node.names);
+      return `INSERT INTO ${this.quoteId(node.table)} (${target}) ${query}${returning}`;
+    }
+    const columns = insertColumns(node.values);
+    const conflict = node.onConflict;
+    const cacheable = conflict?.targetWhere === void 0 && conflict?.updateWhere === void 0 && !insertHasExpression(node);
+    if (!cacheable) return this.compileInsertDirect(node, columns, params);
+    for (const row of node.values) {
+      for (const c of columns) params.bind(row[c] ?? null);
+    }
+    const conflictCols = conflict && conflict.update !== "nothing" ? Object.keys(conflict.update) : [];
+    for (const c of conflictCols) {
+      params.bind((conflict?.update)[c]);
+    }
+    return this.insertTemplate(node, columns, conflictCols, params);
+  }
+  /**
+   * Compile an INSERT without the template cache, rendering clauses in statement
+   * order so every parameter is bound at the position it appears.
+   *
+   * @param node The insert node.
+   * @param columns The column keys shared by every row.
+   * @param params The parameter collector.
+   * @returns The SQL text.
+   */
+  compileInsertDirect(node, columns, params) {
+    const names = node.names;
+    const colSql = columns.map((c) => this.columnId(c, names)).join(", ");
+    const rowsSql = node.values.map((row) => {
+      const cells = columns.map(
+        (c) => this.renderValue(row[c] ?? null, params)
+      );
+      return `(${cells.join(", ")})`;
+    }).join(", ");
+    let sql = `INSERT INTO ${this.quoteId(node.table)} (${colSql}) VALUES ${rowsSql}`;
+    if (node.onConflict) {
+      const update = node.onConflict.update;
+      const conflictCols = update === "nothing" ? [] : Object.keys(update);
+      let cursor = 0;
+      sql += this.renderConflict(
+        node.onConflict,
+        conflictCols,
+        () => {
+          const key = conflictCols[cursor++];
+          return this.renderValue(update[key], params);
+        },
+        names,
+        params
+      );
+    }
+    sql += this.compileReturning(node.returning, names);
+    return sql;
+  }
+  /**
+   * The INSERT SQL template for a given structure, cached across calls.
+   *
+   * The text depends only on (dialect, table, columns, row count, returning,
+   * conflict shape) — never on the bound values — and placeholder positions are
+   * deterministic from the counts (a fresh statement always starts binding at 1).
+   * So a per-row insert loop compiles the string once and reuses it every row.
+   */
+  insertTemplate(node, columns, conflictCols, params) {
+    const returningKey = node.returning === null ? "" : node.returning === "*" ? "*" : node.returning.join(",");
+    const conflictKey = node.onConflict ? `${node.onConflict.target.join(",")}>${node.onConflict.update === "nothing" ? "nothing" : conflictCols.join(",")}` : "";
+    const key = `${this.name}|${node.table}|${columns.join(",")}|${node.values.length}|${returningKey}|${conflictKey}`;
+    const cached = _BaseDialect.insertTemplates.get(key);
+    if (cached !== void 0) return cached;
+    const names = node.names;
+    const colSql = columns.map((c) => this.columnId(c, names)).join(", ");
+    let position = 0;
+    const rowsSql = node.values.map(() => `(${columns.map(() => this.placeholder(++position)).join(", ")})`).join(", ");
+    let sql = `INSERT INTO ${this.quoteId(node.table)} (${colSql}) VALUES ${rowsSql}`;
+    if (node.onConflict) {
+      sql += this.renderConflict(
+        node.onConflict,
+        conflictCols,
+        () => this.placeholder(++position),
+        names,
+        params
+      );
+    }
+    sql += this.compileReturning(node.returning, names);
+    _BaseDialect.insertTemplates.set(key, sql);
+    return sql;
+  }
+  /**
+   * Render the conflict-handling clause. Standard SQL (SQLite/PostgreSQL) uses
+   * `ON CONFLICT (...) [WHERE predicate] DO NOTHING | DO UPDATE SET ... [WHERE ...]`;
+   * MySQL overrides this.
+   *
+   * The index predicate is rendered before the `DO UPDATE` assignments because
+   * that is where it sits in the statement, so its parameters bind first.
+   *
+   * @param onConflict The conflict clause from the node.
+   * @param conflictCols The columns to overwrite on `DO UPDATE` (empty for nothing).
+   * @param nextValue Yields the SQL for the next `DO UPDATE` assignment value.
+   * @param names The node's property → column map, if any.
+   * @param params The parameter collector, for the predicates.
+   * @returns The SQL text, leading space included.
+   */
+  renderConflict(onConflict, conflictCols, nextValue, names, params) {
+    const idFor = (key) => this.columnId(key, names);
+    const target = onConflict.target.map(idFor).join(", ");
+    const indexWhere = this.compileCondition(onConflict.targetWhere, params, idFor);
+    const targetSql = indexWhere ? `(${target}) WHERE ${indexWhere}` : `(${target})`;
+    if (onConflict.update === "nothing") return ` ON CONFLICT ${targetSql} DO NOTHING`;
+    const assignments = conflictCols.map((c) => `${idFor(c)} = ${nextValue()}`).join(", ");
+    let sql = ` ON CONFLICT ${targetSql} DO UPDATE SET ${assignments}`;
+    const updateWhere = this.compileCondition(onConflict.updateWhere, params, idFor);
+    if (updateWhere) sql += ` WHERE ${updateWhere}`;
+    return sql;
+  }
+  compileUpdate(node, params) {
+    const names = node.names;
+    const sets = Object.entries(node.set).map(
+      ([col, value]) => `${this.columnId(col, names)} = ${this.renderValue(value, params)}`
+    ).join(", ");
+    let sql = `UPDATE ${this.quoteId(node.table)} SET ${sets}`;
+    sql += this.compileExtraSources("FROM", node.from);
+    const where = this.compileCondition(
+      node.where,
+      params,
+      (k) => this.columnId(k, names),
+      codecEncoder(node.codecs)
+    );
+    if (where) sql += ` WHERE ${where}`;
+    sql += this.compileReturning(node.returning, names);
+    return sql;
+  }
+  compileDelete(node, params) {
+    const names = node.names;
+    let sql = `DELETE FROM ${this.quoteId(node.table)}`;
+    sql += this.compileExtraSources("USING", node.using);
+    const where = this.compileCondition(
+      node.where,
+      params,
+      (k) => this.columnId(k, names),
+      codecEncoder(node.codecs)
+    );
+    if (where) sql += ` WHERE ${where}`;
+    sql += this.compileReturning(node.returning, names);
+    return sql;
+  }
+  compileJoin(node, params) {
+    const names = node.names;
+    const cols = node.selections.map((s) => {
+      const ref = `${s.alias}.${s.column}`;
+      const label = node.pick ? s.column : ref;
+      return `${this.qualify(ref, names)} AS ${this.quoteId(label)}`;
+    }).join(", ");
+    let sql = `${this.compileWith(node.with, params)}SELECT ${cols} FROM ${this.quoteId(node.base.table)} AS ${this.quoteId(node.base.alias)}`;
+    for (const j of node.joins) {
+      const kw = j.kind === "left" ? "LEFT JOIN" : "INNER JOIN";
+      const on = j.on.map(([l, r]) => `${this.qualify(l, names)} = ${this.qualify(r, names)}`).join(" AND ");
+      sql += ` ${kw} ${this.quoteId(j.table)} AS ${this.quoteId(j.alias)} ON ${on}`;
+    }
+    const where = this.compileCondition(
+      node.where,
+      params,
+      (k) => this.qualify(k, names)
+    );
+    if (where) sql += ` WHERE ${where}`;
+    if (node.orderBy.length > 0) {
+      const terms = node.orderBy.map(
+        (t) => `${this.qualify(t.ref, names)} ${t.direction === "desc" ? "DESC" : "ASC"}`
+      ).join(", ");
+      sql += ` ORDER BY ${terms}`;
+    }
+    if (node.limit !== void 0) sql += ` LIMIT ${params.bind(node.limit)}`;
+    if (node.offset !== void 0) sql += ` OFFSET ${params.bind(node.offset)}`;
+    return sql;
+  }
+  // ---- clauses ----------------------------------------------------------
+  /**
+   * Render the extra sources of an `UPDATE ... FROM` / `DELETE ... USING`.
+   *
+   * The dialects that do not have the clause override this and throw: emitting it
+   * anyway would produce a statement the server rejects, and quietly dropping it
+   * would change which rows are written.
+   *
+   * @param keyword `FROM` or `USING`.
+   * @param sources The extra tables, if any.
+   * @returns The clause with a leading space, or an empty string.
+   */
+  compileExtraSources(keyword, sources) {
+    if (!sources || sources.length === 0) return "";
+    const list = sources.map((s) => `${this.quoteId(s.table)} AS ${this.quoteId(s.alias)}`).join(", ");
+    return ` ${keyword} ${list}`;
+  }
+  compileReturning(returning, names) {
+    if (returning === null) return "";
+    if (returning === "*") return " RETURNING *";
+    return ` RETURNING ${returning.map((c) => this.columnId(c, names)).join(", ")}`;
+  }
+  /**
+   * Compile a condition tree (fields / and / or / not) to SQL. `idFor` renders a
+   * key to a quoted identifier — `quoteId` for single-table, `qualify` for joins —
+   * so select/update/delete/join all share this one compiler.
+   */
+  compileCondition(node, params, idFor, encode = (_key, value) => value) {
+    if (!node) return "";
+    switch (node.kind) {
+      case "fields": {
+        const conditions = [];
+        for (const [key, value] of Object.entries(node.fields)) {
+          const id = idFor(key);
+          if (isExpression(value)) {
+            conditions.push(
+              this.compileExprOperator(
+                id,
+                "eq",
+                this.renderExpr(value.node, params, idFor)
+              )
+            );
+          } else if (isOperatorObject(value)) {
+            for (const [op, operand] of Object.entries(value)) {
+              conditions.push(
+                isExpression(operand) ? this.compileExprOperator(
+                  id,
+                  op,
+                  this.renderExpr(operand.node, params, idFor)
+                ) : this.compileOperator(
+                  id,
+                  op,
+                  encodeOperand(op, operand, (v) => encode(key, v)),
+                  params
+                )
+              );
+            }
+          } else {
+            const operand = encode(key, value);
+            conditions.push(
+              operand === null ? `${id} IS NULL` : `${id} = ${params.bind(operand)}`
+            );
+          }
+        }
+        return conditions.join(" AND ");
+      }
+      case "and":
+      case "or": {
+        const parts = node.parts.map((p) => this.compileCondition(p, params, idFor, encode)).filter((s) => s.length > 0);
+        if (parts.length === 0) return "";
+        const sep = node.kind === "and" ? " AND " : " OR ";
+        return parts.map((p) => `(${p})`).join(sep);
+      }
+      case "not": {
+        const inner = this.compileCondition(node.part, params, idFor, encode);
+        return inner ? `NOT (${inner})` : "";
+      }
+      case "exists": {
+        const select = node.select;
+        this.checkSubquery(select);
+        const keyword = node.negate ? "NOT EXISTS" : "EXISTS";
+        return `${keyword} (${this.compileSelect(select, params)})`;
+      }
+      case "fullText":
+        return this.compileFullText(node, params, idFor);
+      case "compare": {
+        const left = this.renderExpr(node.left, params, idFor);
+        if (node.right.kind === "value") {
+          return this.compileOperator(left, node.op, node.right.value, params);
+        }
+        return this.compileExprOperator(
+          left,
+          node.op,
+          this.renderExpr(node.right, params, idFor)
+        );
+      }
+    }
+  }
+  /**
+   * Compile a full-text condition.
+   *
+   * PostgreSQL gets the real thing (`@@ websearch_to_tsquery`); the dialects with
+   * no text-search engine override this and compile the node's prebuilt substring
+   * fallback instead, so the query still returns the right rows.
+   *
+   * @param node The full-text condition node.
+   * @param params The parameter collector.
+   * @param idFor Column-name resolver.
+   * @returns The rendered condition.
+   */
+  compileFullText(node, params, idFor) {
+    const config = params.bind(node.language);
+    return `${this.tsVector(node.columns, config, idFor)} @@ websearch_to_tsquery(${config}::regconfig, ${params.bind(node.term)})`;
+  }
+  /**
+   * Render one side of a comparison.
+   *
+   * A column reference goes through `idFor`, so an explicit `.name()` mapping and
+   * join qualification apply here exactly as they do in the object form of
+   * `where` — `col()` is not a way around them. Only a `value` node binds.
+   *
+   * @param node The expression AST.
+   * @param params The parameter collector.
+   * @param idFor The identifier resolver for the enclosing statement.
+   * @returns The SQL text of the expression.
+   */
+  /**
+   * Render what an aggregate is applied to: `*`, a column, or an expression.
+   *
+   * An expression operand is what makes a conditional aggregate
+   * (`SUM(CASE WHEN ... END)`) expressible — one pass over the table instead of a
+   * query per bucket.
+   *
+   * @param agg The aggregate term.
+   * @param params The parameter collector.
+   * @param names The node's column-name map.
+   * @returns The rendered operand.
+   */
+  aggregateOperand(agg, params, names) {
+    if (agg.column === "*") return "*";
+    if (typeof agg.column === "string") return this.columnId(agg.column, names);
+    return this.renderExpr(agg.column, params, (k) => this.columnId(k, names));
+  }
+  renderExpr(node, params, idFor) {
+    switch (node.kind) {
+      case "column":
+        return idFor(node.name);
+      case "value":
+        return params.bind(node.value);
+      case "fn": {
+        const args = node.args.map((a) => this.renderExpr(a, params, idFor)).join(", ");
+        return `${node.name}(${args})`;
+      }
+      case "case": {
+        const branches = node.branches.map(
+          (b) => `WHEN ${this.compileCondition(b.when, params, idFor)} THEN ${this.renderExpr(b.result, params, idFor)}`
+        ).join(" ");
+        const fallback = node.fallback === null ? "" : ` ELSE ${this.renderExpr(node.fallback, params, idFor)}`;
+        return `CASE ${branches}${fallback} END`;
+      }
+      case "cast":
+        return `CAST(${this.renderExpr(node.operand, params, idFor)} AS ${this.castTypeName(node.to)})`;
+      case "scalar": {
+        const select = node.select;
+        this.checkSubquery(select);
+        return `(${this.compileSelect(select, params)})`;
+      }
+      case "rank":
+        return this.renderRank(node.columns, node.term, node.language, params, idFor);
+      case "star":
+        return "*";
+      case "window": {
+        const call = this.renderExpr(node.fn, params, idFor);
+        const parts = [];
+        if (node.partitionBy.length > 0) {
+          parts.push(`PARTITION BY ${node.partitionBy.map(idFor).join(", ")}`);
+        }
+        if (node.orderBy.length > 0) {
+          const terms = node.orderBy.map((t) => `${idFor(t.column)} ${t.direction === "desc" ? "DESC" : "ASC"}`).join(", ");
+          parts.push(`ORDER BY ${terms}`);
+        }
+        if (node.frame) parts.push(node.frame);
+        return `${call} OVER (${parts.join(" ")})`;
+      }
+    }
+  }
+  /**
+   * Render a full-text relevance score.
+   *
+   * PostgreSQL has `ts_rank`; the others have nothing equivalent, and they
+   * override this to a constant so that ordering by it is a no-op rather than a
+   * compile error — the fallback keeps returning the right rows, only unranked.
+   *
+   * @param columns The columns making up the document.
+   * @param term The search term.
+   * @param language The text-search configuration.
+   * @param params The parameter collector.
+   * @param idFor Column-name resolver.
+   * @returns The rendered score expression.
+   */
+  renderRank(columns, term, language, params, idFor) {
+    const config = params.bind(language);
+    return `ts_rank(${this.tsVector(columns, config, idFor)}, websearch_to_tsquery(${config}::regconfig, ${params.bind(term)}))`;
+  }
+  /**
+   * Build the `to_tsvector(...)` document out of the searched columns.
+   *
+   * `coalesce(col, '')` matters: in SQL a `NULL` anywhere in a concatenation makes
+   * the whole document `NULL`, so one empty column would silently exclude the row.
+   *
+   * @param columns The columns making up the document.
+   * @param config The already-bound placeholder for the text-search config.
+   * @param idFor Column-name resolver.
+   * @returns The rendered `to_tsvector(...)` call.
+   */
+  tsVector(columns, config, idFor) {
+    const document = columns.map((c) => `coalesce(${idFor(c)}, '')`).join(" || ' ' || ");
+    return `to_tsvector(${config}::regconfig, ${document})`;
+  }
+  /**
+   * The SQL type name this dialect accepts in a `CAST`.
+   *
+   * The base mapping is the standard one PostgreSQL takes; SQLite and MySQL
+   * override it, because the names genuinely differ (MySQL's `CAST(x AS SIGNED)`
+   * is not `INTEGER`, and SQLite only has five storage classes to aim at).
+   *
+   * @param to The portable cast target.
+   * @returns The dialect's own type name.
+   */
+  castTypeName(to) {
+    switch (to) {
+      case "integer":
+        return "INTEGER";
+      case "bigint":
+        return "BIGINT";
+      case "real":
+        return "DOUBLE PRECISION";
+      case "numeric":
+        return "NUMERIC";
+      case "text":
+        return "TEXT";
+      case "boolean":
+        return "BOOLEAN";
+      case "date":
+        return "DATE";
+      case "datetime":
+      case "timestamp":
+        return "TIMESTAMP";
+      case "uuid":
+        return "UUID";
+      case "json":
+        return "JSON";
+      case "jsonb":
+        return "JSONB";
+      case "blob":
+        return "BYTEA";
+    }
+  }
+  /**
+   * Compile a comparison whose right-hand side is another expression rather than
+   * a bound value (`total > paid`, `lower(a) = lower(b)`).
+   *
+   * The list and null operators are excluded: `IN`, `BETWEEN` and `IS NULL` take
+   * a value operand, and accepting an expression there would silently compile to
+   * something else.
+   *
+   * @param left The rendered left-hand side.
+   * @param op The operator name.
+   * @param right The rendered right-hand side.
+   * @returns The SQL text of the predicate.
+   * @throws Error When the operator needs a value operand.
+   */
+  compileExprOperator(left, op, right) {
+    switch (op) {
+      case "eq":
+        return `${left} = ${right}`;
+      case "ne":
+        return `${left} <> ${right}`;
+      case "gt":
+        return `${left} > ${right}`;
+      case "gte":
+        return `${left} >= ${right}`;
+      case "lt":
+        return `${left} < ${right}`;
+      case "lte":
+        return `${left} <= ${right}`;
+      case "like":
+        return `${left} LIKE ${right}`;
+      case "ilike":
+        return this.ilike(left, right);
+      case "ieq":
+        return `lower(${left}) = lower(${right})`;
+      case "iContains":
+        throw new Error(
+          'The "iContains" operator matches a literal, so it takes a value, not an expression.'
+        );
+      case "contains":
+      case "containedBy":
+      case "overlaps":
+        return `${left} ${this.arrayOperator(op)} ${right}`;
+      default:
+        throw new Error(`The "${op}" operator takes a value operand, not an expression.`);
+    }
+  }
+  compileOperator(id, op, operand, params) {
+    switch (op) {
+      case "eq":
+        return operand === null ? `${id} IS NULL` : `${id} = ${params.bind(operand)}`;
+      case "ne":
+        return operand === null ? `${id} IS NOT NULL` : `${id} <> ${params.bind(operand)}`;
+      case "gt":
+        return `${id} > ${params.bind(operand)}`;
+      case "gte":
+        return `${id} >= ${params.bind(operand)}`;
+      case "lt":
+        return `${id} < ${params.bind(operand)}`;
+      case "lte":
+        return `${id} <= ${params.bind(operand)}`;
+      case "like":
+        return `${id} LIKE ${params.bind(operand)}`;
+      case "ilike":
+        return this.ilike(id, params.bind(operand));
+      case "ieq":
+        return operand === null ? `${id} IS NULL` : `lower(${id}) = lower(${params.bind(operand)})`;
+      case "iContains":
+        return this.ilikeEscaped(id, params.bind(`%${escapeLike(String(operand))}%`));
+      case "contains":
+        return `${id} ${this.arrayOperator("contains")} ${params.bind(operand)}`;
+      case "containedBy":
+        return `${id} ${this.arrayOperator("containedBy")} ${params.bind(operand)}`;
+      case "overlaps":
+        return `${id} ${this.arrayOperator("overlaps")} ${params.bind(operand)}`;
+      case "in":
+        return this.compileIn(id, operand, params, false);
+      case "notIn":
+        return this.compileIn(id, operand, params, true);
+      case "between": {
+        const [lo, hi] = operand;
+        return `${id} BETWEEN ${params.bind(lo)} AND ${params.bind(hi)}`;
+      }
+      case "isNull":
+        return operand ? `${id} IS NULL` : `${id} IS NOT NULL`;
+      default:
+        throw new Error(`Unknown operator ${JSON.stringify(op)}`);
+    }
+  }
+  /**
+   * Compile `IN` / `NOT IN`, whose operand is either a value list or a
+   * single-column subquery.
+   *
+   * The subquery is rendered at the position it appears in the outer statement
+   * and shares the same parameter collector, so its own placeholders land in the
+   * right order — and it keeps its own `names` map, since the inner model may use
+   * a different naming convention than the outer one.
+   *
+   * @param id The quoted column identifier being tested.
+   * @param operand A list of values, or a {@link Subquery}.
+   * @param params The parameter collector for the statement being compiled.
+   * @param negate True for `NOT IN`.
+   * @returns The SQL text of the predicate.
+   */
+  compileIn(id, operand, params, negate) {
+    const keyword = negate ? "NOT IN" : "IN";
+    if (isSubquery(operand)) {
+      this.checkSubquery(operand.node);
+      return `${id} ${keyword} (${this.compileSelect(operand.node, params)})`;
+    }
+    const values = operand;
+    if (values.length === 0) {
+      return negate ? "1 = 1" : "1 = 0";
+    }
+    const list = values.map((v) => params.bind(v)).join(", ");
+    return `${id} ${keyword} (${list})`;
+  }
+};
+var SqliteDialect = class extends BaseDialect {
+  name = "sqlite";
+  /**
+   * SQLite explains with `EXPLAIN QUERY PLAN`, and has no `ANALYZE` — the plain
+   * `EXPLAIN` there dumps bytecode, which answers a different question.
+   */
+  explainPrefix(analyze) {
+    if (analyze) {
+      throw new Error(
+        "SQLite has no EXPLAIN ANALYZE; use EXPLAIN QUERY PLAN (analyze: false)."
+      );
+    }
+    return "EXPLAIN QUERY PLAN";
+  }
+  /**
+   * SQLite has `UPDATE ... FROM` (3.33+) but no `DELETE ... USING`.
+   *
+   * The portable shape there is a subquery — `where({ id: { in: … } })` — so this
+   * throws and says so, rather than emitting a clause SQLite does not parse.
+   */
+  compileExtraSources(keyword, sources) {
+    if (keyword === "USING" && sources && sources.length > 0) {
+      throw new Error(
+        'SQLite has no DELETE ... USING; filter with a subquery instead: where({ id: { in: select(Other, ["id"]).asSubquery("id") } }).'
+      );
+    }
+    return super.compileExtraSources(keyword, sources);
+  }
+  /**
+   * SQLite has no text-search engine, so the prebuilt substring fallback is
+   * compiled instead. The rows are right; the ranking is what is missing.
+   */
+  compileFullText(node, params, idFor) {
+    return this.compileCondition(node.fallback, params, idFor);
+  }
+  /** No text-search engine means no score: a constant, so ordering by it is inert. */
+  renderRank() {
+    return "0";
+  }
+  /**
+   * SQLite has five storage classes, so most targets collapse onto `TEXT` or
+   * `INTEGER`. Naming a type it does not know would not fail — SQLite applies the
+   * closest affinity — but it would make the cast mean something different here
+   * than on the other databases, which is what this mapping avoids.
+   */
+  castTypeName(to) {
+    switch (to) {
+      case "integer":
+      case "bigint":
+      case "boolean":
+        return "INTEGER";
+      case "real":
+        return "REAL";
+      case "numeric":
+        return "NUMERIC";
+      case "blob":
+        return "BLOB";
+      default:
+        return "TEXT";
+    }
+  }
+  placeholder() {
+    return "?";
+  }
+  ilike(column, param) {
+    return `${column} LIKE ${param}`;
+  }
+  /**
+   * SQLite runs one writer at a time, so its only isolation level **is**
+   * serializable — there is no syntax to ask for another, and no weaker level to
+   * fall back to. Asking for one is an error rather than a silent no-op, since a
+   * caller who wrote `repeatable read` was reasoning about a guarantee.
+   *
+   * `readOnly` likewise has no per-transaction form here (`PRAGMA query_only` is
+   * per connection), so it is refused instead of quietly ignored.
+   */
+  beginStatements(options) {
+    if (options?.isolation && options.isolation !== "serializable") {
+      throw new Error(
+        `SQLite only implements the "serializable" isolation level; ${JSON.stringify(options.isolation)} has no equivalent here.`
+      );
+    }
+    if (options?.readOnly) {
+      throw new Error(
+        "SQLite has no read-only transaction; open the engine with { sqlite: { ... } } on a read-only connection instead."
+      );
+    }
+    return ["BEGIN"];
+  }
+  /**
+   * SQLite has no row-level locking, so a lock request is an error rather than a
+   * silently unlocked `SELECT` — a lock that does not exist only shows up as
+   * duplicated work under production concurrency.
+   */
+  renderLock() {
+    throw new Error(
+      "SQLite has no row-level locking \u2014 FOR UPDATE / FOR SHARE is unsupported. Serialize the claim inside a transaction instead."
+    );
+  }
+};
+var PostgresDialect = class extends BaseDialect {
+  name = "postgresql";
+  placeholder(index) {
+    return `$${index}`;
+  }
+  ilike(column, param) {
+    return `${column} ILIKE ${param}`;
+  }
+  arrayOperator(op) {
+    if (op === "contains") return "@>";
+    if (op === "containedBy") return "<@";
+    return "&&";
+  }
+};
+var mysqlQuotedIds = /* @__PURE__ */ new Map();
+var MysqlDialect = class extends BaseDialect {
+  name = "mysql";
+  placeholder() {
+    return "?";
+  }
+  ilike(column, param) {
+    return `${column} LIKE ${param}`;
+  }
+  /** MySQL's `EXPLAIN FORMAT=JSON` spells the option differently. */
+  explainPrefix(analyze) {
+    return analyze ? "EXPLAIN ANALYZE" : "EXPLAIN FORMAT=JSON";
+  }
+  /**
+   * MySQL only gained `INTERSECT`/`EXCEPT` in 8.0.31, and this project does not
+   * invest in MySQL beyond what already works — so they are refused here rather
+   * than emitted against a server that may reject them.
+   */
+  setOperator(op) {
+    if (op === "intersect" || op === "except") {
+      throw new Error(
+        `MySQL support for ${op.toUpperCase()} is out of scope for tempest-db-js; express it with a join or NOT EXISTS.`
+      );
+    }
+    return super.setOperator(op);
+  }
+  /**
+   * MySQL writes multi-table updates as `UPDATE a JOIN b`, and has no
+   * `DELETE ... USING` in this shape. Both are out of the project's active scope,
+   * so they are refused rather than emitted against a server that rejects them.
+   */
+  compileExtraSources(keyword, sources) {
+    if (sources && sources.length > 0) {
+      throw new Error(
+        `MySQL does not take ${keyword} on a write in this form; it spells multi-table writes as UPDATE a JOIN b, which is out of scope for tempest-db-js.`
+      );
+    }
+    return "";
+  }
+  /**
+   * MySQL's full-text search needs a `FULLTEXT` index and different syntax, and it
+   * is outside this project's active scope — the substring fallback is compiled,
+   * like on SQLite.
+   */
+  compileFullText(node, params, idFor) {
+    return this.compileCondition(node.fallback, params, idFor);
+  }
+  /** No `ts_rank` equivalent in scope: a constant, so ordering by it is inert. */
+  renderRank() {
+    return "0";
+  }
+  /**
+   * MySQL sets the level with a statement **before** the transaction opens, and
+   * spells the read-only flag on `START TRANSACTION` rather than on `BEGIN`.
+   */
+  beginStatements(options) {
+    const statements = [];
+    if (options?.isolation) {
+      statements.push(
+        `SET TRANSACTION ISOLATION LEVEL ${options.isolation.toUpperCase()}`
+      );
+    }
+    statements.push(options?.readOnly ? "START TRANSACTION READ ONLY" : "BEGIN");
+    return statements;
+  }
+  /**
+   * MySQL's `CAST` takes its own vocabulary — `SIGNED`, not `INTEGER`; `CHAR`,
+   * not `TEXT` — and rejects the standard names outright.
+   */
+  castTypeName(to) {
+    switch (to) {
+      case "integer":
+      case "bigint":
+      case "boolean":
+        return "SIGNED";
+      case "real":
+      case "numeric":
+        return "DECIMAL";
+      case "text":
+      case "uuid":
+        return "CHAR";
+      case "date":
+        return "DATE";
+      case "datetime":
+      case "timestamp":
+        return "DATETIME";
+      case "json":
+      case "jsonb":
+        return "JSON";
+      case "blob":
+        return "BINARY";
+    }
+  }
+  quoteId(name) {
+    const cached = mysqlQuotedIds.get(name);
+    if (cached !== void 0) return cached;
+    const quoted = `\`${name.replace(/`/g, "``")}\``;
+    mysqlQuotedIds.set(name, quoted);
+    return quoted;
+  }
+  /**
+   * MySQL rejects `LIMIT` inside an `IN` subquery with
+   * `ER_NOT_SUPPORTED_YET: This version of MySQL doesn't yet support
+   * 'LIMIT & IN/ALL/ANY/SOME subquery'`. Failing at compile time names the fix
+   * instead of surfacing that error from the driver at runtime.
+   */
+  checkSubquery(node) {
+    if (node.limit !== void 0 || node.offset !== void 0) {
+      throw new Error(
+        "MySQL does not support LIMIT/OFFSET inside an IN subquery. Select the ids first and pass them as a list, or wrap the subquery in a derived table."
+      );
+    }
+  }
+  renderConflict(onConflict, conflictCols, nextValue, names) {
+    if (onConflict.targetWhere || onConflict.updateWhere) {
+      throw new Error(
+        "MySQL's ON DUPLICATE KEY UPDATE has no conflict-target predicate \u2014 a partial unique index is PostgreSQL/SQLite only."
+      );
+    }
+    if (onConflict.update === "nothing") {
+      const col = this.columnId(onConflict.target[0] ?? "id", names);
+      return ` ON DUPLICATE KEY UPDATE ${col} = ${col}`;
+    }
+    const assignments = conflictCols.map((c) => `${this.columnId(c, names)} = ${nextValue()}`).join(", ");
+    return ` ON DUPLICATE KEY UPDATE ${assignments}`;
+  }
+  /**
+   * MySQL has no `RETURNING`, so it cannot be compiled into a statement.
+   *
+   * `session.execute()` still honors `.returning()` on a **single-row INSERT** by
+   * running the insert and reading the row back by key on the same connection —
+   * that is execution, not compilation, so it never reaches here. Compiling a
+   * node with `returning` directly is an error, rather than SQL that silently
+   * returns nothing.
+   */
+  compileReturning(returning) {
+    if (returning === null) return "";
+    throw new Error(
+      "RETURNING cannot be compiled for MySQL. session.execute() reads a single-row INSERT back by key (LAST_INSERT_ID()); UPDATE/DELETE have no equivalent \u2014 run a SELECT yourself."
+    );
+  }
+};
+function getDialect(name) {
+  switch (name) {
+    case "sqlite":
+      return new SqliteDialect();
+    case "postgresql":
+      return new PostgresDialect();
+    case "mysql":
+      return new MysqlDialect();
+  }
+}
 module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 function toAsyncDriver(driver) {
   return {
@@ -31,6 +1423,10 @@ function toAsyncDriver(driver) {
 }
 
 // src/index.ts
+var EXPRESSION = /* @__PURE__ */ Symbol.for("tempest-db-js.expression");
+function isSqlExpression(value) {
+  return typeof value === "object" && value !== null && value[EXPRESSION] === true;
+}
 function isDefaultValue(value) {
   return typeof value === "object" && value !== null && "kind" in value && (value.kind === "literal" || value.kind === "expression");
 }
@@ -50,13 +1446,14 @@ function parseReference(ref, options) {
   };
 }
 var Column = class _Column {
-  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null, dbName = null) {
+  constructor(type, flags, defaultValue = null, onUpdateValue = null, reference = null, dbName = null, codec = null) {
     this.type = type;
     this.flags = flags;
     this.defaultValue = defaultValue;
     this.onUpdateValue = onUpdateValue;
     this.reference = reference;
     this.dbName = dbName;
+    this.codec = codec;
   }
   type;
   flags;
@@ -64,6 +1461,7 @@ var Column = class _Column {
   onUpdateValue;
   reference;
   dbName;
+  codec;
   /** Clone this column with one facet replaced, carrying every other over. */
   derive(patch) {
     return new _Column(
@@ -72,7 +1470,8 @@ var Column = class _Column {
       patch.defaultValue !== void 0 ? patch.defaultValue : this.defaultValue,
       patch.onUpdateValue !== void 0 ? patch.onUpdateValue : this.onUpdateValue,
       patch.reference !== void 0 ? patch.reference : this.reference,
-      patch.dbName !== void 0 ? patch.dbName : this.dbName
+      patch.dbName !== void 0 ? patch.dbName : this.dbName,
+      patch.codec !== void 0 ? patch.codec : this.codec
     );
   }
   primaryKey() {
@@ -214,6 +1613,41 @@ function columnNamesOf(model) {
 function constraintName(prefix, table, columns) {
   return `${prefix}_${table}_${columns.join("_")}`;
 }
+function renameConditionColumns(node, toColumn) {
+  const expr = (current) => {
+    switch (current.kind) {
+      case "column":
+        return { kind: "column", name: toColumn(current.name) };
+      case "fn":
+        return { ...current, args: current.args.map(expr) };
+      case "cast":
+        return { ...current, operand: expr(current.operand) };
+      default:
+        return current;
+    }
+  };
+  switch (node.kind) {
+    case "fields": {
+      const fields = {};
+      for (const [key, value] of Object.entries(node.fields)) {
+        fields[toColumn(key)] = value;
+      }
+      return { kind: "fields", fields };
+    }
+    case "and":
+    case "or":
+      return {
+        ...node,
+        parts: node.parts.map((part) => renameConditionColumns(part, toColumn))
+      };
+    case "not":
+      return { kind: "not", part: renameConditionColumns(node.part, toColumn) };
+    case "compare":
+      return { ...node, left: expr(node.left), right: expr(node.right) };
+    default:
+      return node;
+  }
+}
 function reflectTable(model) {
   const names = columnNamesOf(model);
   const toColumn = (prop) => names?.[prop] ?? prop;
@@ -235,6 +1669,8 @@ function reflectTable(model) {
   }
   const uniqueConstraints = [];
   const foreignKeys = [];
+  const checks = [];
+  const indexes = [];
   for (const c of model.tableArgs?.() ?? []) {
     const cols = c.columns.map(toColumn);
     if (c.kind === "unique") {
@@ -242,6 +1678,18 @@ function reflectTable(model) {
         name: c.name ?? constraintName("uq", model.tablename, cols),
         columns: cols
       });
+    } else if (c.kind === "check") {
+      checks.push({
+        name: c.name ?? constraintName("ck", model.tablename, cols),
+        expression: renameConditionColumns(c.expression, toColumn)
+      });
+    } else if (c.kind === "index") {
+      indexes.push({
+        name: c.name ?? constraintName("ix", model.tablename, cols),
+        columns: cols,
+        unique: c.unique === true,
+        where: c.where ? renameConditionColumns(c.where, toColumn) : null
+      });
     } else {
       foreignKeys.push({
         name: c.name ?? constraintName("fk", model.tablename, cols),
@@ -253,7 +1701,15 @@ function reflectTable(model) {
       });
     }
   }
-  return { name: model.tablename, columns, primaryKey, uniqueConstraints, foreignKeys };
+  return {
+    name: model.tablename,
+    columns,
+    primaryKey,
+    uniqueConstraints,
+    foreignKeys,
+    checks,
+    indexes
+  };
 }
 function reflectSchema(models) {
   const tables = {};
@@ -300,6 +1756,10 @@ function invert(op) {
       return { kind: "recreate_table", from: op.to, to: op.from };
     case "add_constraint":
       return { kind: "drop_constraint", table: op.table, constraint: op.constraint };
+    case "create_index":
+      return { kind: "drop_index", table: op.table, index: op.index };
+    case "drop_index":
+      return { kind: "create_index", table: op.table, index: op.index };
     case "drop_constraint":
       return { kind: "add_constraint", table: op.table, constraint: op.constraint };
     case "execute":
@@ -443,7 +1903,8 @@ function renderDefault(def, dialect, type) {
         "sql.expr`...` binds parameters and cannot be rendered as a DEFAULT \u2014 use sql.raw()."
       );
     }
-    return renderPortableToken(expr, dialect);
+    const rendered = renderPortableToken(expr, dialect);
+    return dialect === "sqlite" && rendered.includes("(") ? `(${rendered})` : rendered;
   }
   const value = def.value;
   if (value === null) return "NULL";
@@ -491,9 +1952,31 @@ function renderForeignKeyConstraint(fk, dialect) {
 function tableConstraintClauses(table, dialect) {
   return [
     ...table.uniqueConstraints.map((uc) => renderUniqueConstraint(uc, dialect)),
-    ...table.foreignKeys.map((fk) => renderForeignKeyConstraint(fk, dialect))
+    ...table.foreignKeys.map((fk) => renderForeignKeyConstraint(fk, dialect)),
+    ...table.checks.map((ck) => renderCheckConstraint(ck, dialect))
   ];
 }
+function renderPredicate(node, dialect) {
+  const literals = new LiteralParams();
+  return getDialect(dialect).renderConditionLiteral(node, literals);
+}
+function renderCheckConstraint(ck, dialect) {
+  return `CONSTRAINT ${quoteId(ck.name, dialect)} CHECK (${renderPredicate(ck.expression, dialect)})`;
+}
+function renderCreateIndex(table, ix, dialect) {
+  if (ix.where && dialect === "mysql") {
+    throw new Error(
+      `MySQL has no partial index; ${ix.name} on ${table} declares a WHERE predicate.`
+    );
+  }
+  const unique = ix.unique ? "UNIQUE " : "";
+  const cols = ix.columns.map((c) => quoteId(c, dialect)).join(", ");
+  const where = ix.where ? ` WHERE ${renderPredicate(ix.where, dialect)}` : "";
+  return `CREATE ${unique}INDEX ${quoteId(ix.name, dialect)} ON ${quoteId(table, dialect)} (${cols})${where}`;
+}
+function renderDropIndex(table, ix, dialect) {
+  return dialect === "mysql" ? `DROP INDEX ${quoteId(ix.name, dialect)} ON ${quoteId(table, dialect)}` : `DROP INDEX ${quoteId(ix.name, dialect)}`;
+}
 function renderColumnDef(col, dialect) {
   let sql = `${quoteId(col.name, dialect)} ${renderColumnType(col.type, dialect)}`;
   if (col.notNull) sql += " NOT NULL";
@@ -546,7 +2029,10 @@ function renderCreateTable(table, dialect) {
     ...typeStmts,
     `CREATE TABLE ${quoteId(table.name, dialect)} (
   ${cols.join(",\n  ")}
-)`
+)`,
+    // Indexes are separate statements, not table clauses — which is also why a
+    // SQLite table rebuild has to recreate them.
+    ...table.indexes.map((ix) => renderCreateIndex(table.name, ix, dialect))
   ];
 }
 function renderOperation(op, dialect) {
@@ -579,6 +2065,10 @@ function renderOperation(op, dialect) {
       return renderAddConstraint(op.table, op.constraint, dialect);
     case "drop_constraint":
       return renderDropConstraint(op.table, op.constraint, dialect);
+    case "create_index":
+      return [renderCreateIndex(op.table, op.index, dialect)];
+    case "drop_index":
+      return [renderDropIndex(op.table, op.index, dialect)];
     case "execute":
       return [op.up];
   }
@@ -589,7 +2079,7 @@ function renderAddConstraint(table, constraint, dialect) {
       `add_constraint on SQLite needs a table-rebuild (recreate_table); constraint ${constraint.constraint.name} on ${table}`
     );
   }
-  const clause = constraint.type === "unique" ? renderUniqueConstraint(constraint.constraint, dialect) : renderForeignKeyConstraint(constraint.constraint, dialect);
+  const clause = constraint.type === "unique" ? renderUniqueConstraint(constraint.constraint, dialect) : constraint.type === "check" ? renderCheckConstraint(constraint.constraint, dialect) : renderForeignKeyConstraint(constraint.constraint, dialect);
   return [`ALTER TABLE ${quoteId(table, dialect)} ADD ${clause}`];
 }
 function renderDropConstraint(table, constraint, dialect) {
@@ -626,6 +2116,10 @@ function renderSqliteRebuild(from, to) {
     common.length > 0 ? `INSERT INTO ${quoteId(tmp, "sqlite")} (${commonSql}) SELECT ${commonSql} FROM ${quoteId(from.name, "sqlite")}` : `-- no common columns to copy from ${from.name}`,
     `DROP TABLE ${quoteId(from.name, "sqlite")}`,
     `ALTER TABLE ${quoteId(tmp, "sqlite")} RENAME TO ${quoteId(to.name, "sqlite")}`,
+    // The rebuild dropped the old table, and its indexes with it: SQLite ties an
+    // index to the table it was created on. Recreating them is part of the
+    // rebuild, not a follow-up somebody has to remember.
+    ...to.indexes.map((ix) => renderCreateIndex(to.name, ix, "sqlite")),
     "PRAGMA foreign_keys=on"
   ];
 }
@@ -728,8 +2222,49 @@ function diffConstraints(current, target) {
       ops.push(addForeignKey(table, tgt));
     }
   }
+  const currentCk = new Map(current.checks.map((c) => [c.name, c]));
+  const targetCk = new Map(target.checks.map((c) => [c.name, c]));
+  for (const [name, cur] of currentCk) {
+    const tgt = targetCk.get(name);
+    if (!tgt || checkSignature(cur) !== checkSignature(tgt)) {
+      ops.push({ kind: "drop_constraint", table, constraint: checkNamed(cur) });
+    }
+  }
+  for (const [name, tgt] of targetCk) {
+    const cur = currentCk.get(name);
+    if (!cur || checkSignature(cur) !== checkSignature(tgt)) {
+      ops.push({ kind: "add_constraint", table, constraint: checkNamed(tgt) });
+    }
+  }
+  const currentIx = new Map(current.indexes.map((i) => [i.name, i]));
+  const targetIx = new Map(target.indexes.map((i) => [i.name, i]));
+  for (const [name, cur] of currentIx) {
+    const tgt = targetIx.get(name);
+    if (!tgt || indexSignature(cur) !== indexSignature(tgt)) {
+      ops.push({ kind: "drop_index", table, index: cur });
+    }
+  }
+  for (const [name, tgt] of targetIx) {
+    const cur = currentIx.get(name);
+    if (!cur || indexSignature(cur) !== indexSignature(tgt)) {
+      ops.push({ kind: "create_index", table, index: tgt });
+    }
+  }
   return ops;
 }
+function checkSignature(ck) {
+  return JSON.stringify(ck.expression);
+}
+function indexSignature(ix) {
+  return JSON.stringify({
+    columns: ix.columns,
+    unique: ix.unique,
+    where: ix.where
+  });
+}
+function checkNamed(ck) {
+  return { type: "check", constraint: ck };
+}
 function uniqueNamed(uc) {
   return { type: "unique", constraint: uc };
 }
@@ -1183,6 +2718,8 @@ function introspectSqlite(driver) {
       columns,
       primaryKey,
       uniqueConstraints: sqliteUniques(driver, tableName),
+      checks: [],
+      indexes: sqliteIndexes(driver, tableName),
       foreignKeys: sqliteForeignKeys(driver, tableName)
     };
   }
@@ -1271,6 +2808,7 @@ function compareSqliteSchemas(actual, expected) {
         );
       }
     }
+    issues.push(...indexDrift(tableName, actualTable, expectedTable));
   }
   for (const tableName of Object.keys(actual.tables)) {
     if (!expected.tables[tableName]) {
@@ -1321,9 +2859,58 @@ function sqliteUniqueFromPragma(table, rows) {
   if (cols.length === 0) return null;
   return { name: `uq_${table}_${cols.join("_")}`, columns: cols };
 }
+function indexesFromPragma(rows, columnsOfIndex) {
+  const indexes = [];
+  for (const idx of rows) {
+    if (idx.origin !== "c") continue;
+    if (idx.partial === 1) continue;
+    const cols = [...columnsOfIndex(idx.name)].sort((a, b) => a.seqno - b.seqno).map((c) => c.name);
+    if (cols.length === 0) continue;
+    indexes.push({
+      name: idx.name,
+      columns: cols,
+      unique: Number(idx.unique) === 1,
+      where: null
+    });
+  }
+  return indexes;
+}
+function sqliteIndexes(driver, table) {
+  const rows = driver.execute(`PRAGMA index_list(${JSON.stringify(table)})`, []).rows;
+  return indexesFromPragma(
+    rows,
+    (name) => driver.execute(`PRAGMA index_info(${JSON.stringify(name)})`, []).rows
+  );
+}
 function isUniqueIndex(idx) {
   return Number(idx.unique) === 1 && idx.origin !== "pk";
 }
+function indexDrift(tableName, actual, expected) {
+  const issues = [];
+  const signature = (ix) => `${ix.columns.join(",")}${ix.unique ? " unique" : ""}`;
+  const actualByName = new Map(actual.indexes.map((ix) => [ix.name, ix]));
+  const expectedByName = new Map(expected.indexes.map((ix) => [ix.name, ix]));
+  for (const [name, exp] of expectedByName) {
+    const act = actualByName.get(name);
+    if (!act) {
+      issues.push(`index "${tableName}.${name}" is missing from the database`);
+      continue;
+    }
+    if (signature(act) !== signature(exp)) {
+      issues.push(
+        `index "${tableName}.${name}" differs: model (${signature(exp)}), db (${signature(act)})`
+      );
+    }
+  }
+  for (const name of actualByName.keys()) {
+    if (!expectedByName.has(name)) {
+      issues.push(
+        `index "${tableName}.${name}" exists in the database but not in the model`
+      );
+    }
+  }
+  return issues;
+}
 var SQLITE_TABLES_SQL = "SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name != 'tempest_db_js_migrations'";
 async function introspectSqliteAsync(driver) {
   const tablesRows = (await driver.execute(SQLITE_TABLES_SQL, [])).rows;
@@ -1341,12 +2928,27 @@ async function introspectSqliteAsync(driver) {
       const unique = sqliteUniqueFromPragma(tableName, cols);
       if (unique) uniqueConstraints.push(unique);
     }
+    const explicitIndexes = [];
+    for (const idx of indexes) {
+      if (idx.origin !== "c" || idx.partial === 1) continue;
+      const cols = (await driver.execute(`PRAGMA index_info(${JSON.stringify(idx.name)})`, [])).rows;
+      const sorted = [...cols].sort((a, b) => a.seqno - b.seqno).map((c) => c.name);
+      if (sorted.length === 0) continue;
+      explicitIndexes.push({
+        name: idx.name,
+        columns: sorted,
+        unique: Number(idx.unique) === 1,
+        where: null
+      });
+    }
     tables[tableName] = {
       name: tableName,
       columns,
       primaryKey,
       uniqueConstraints,
-      foreignKeys: sqliteForeignKeysFromPragma(tableName, fkRows)
+      foreignKeys: sqliteForeignKeysFromPragma(tableName, fkRows),
+      checks: [],
+      indexes: explicitIndexes
     };
   }
   return { tables };
@@ -1472,6 +3074,8 @@ async function introspectPostgres(driver) {
       columns,
       primaryKey,
       uniqueConstraints: await postgresUniques(driver, tableName),
+      checks: [],
+      indexes: await postgresIndexes(driver, tableName),
       foreignKeys: await postgresForeignKeys(driver, tableName)
     };
   }
@@ -1514,6 +3118,29 @@ async function postgresUniques(driver, table) {
     columns: r.cols ?? []
   }));
 }
+async function postgresIndexes(driver, table) {
+  const { rows } = await driver.execute(
+    `SELECT i.relname AS name,
+            ix.indisunique AS is_unique,
+            ix.indpred IS NOT NULL AS is_partial,
+            array_to_string(array_agg(a.attname ORDER BY k.ord), ',') AS columns
+       FROM pg_index ix
+       JOIN pg_class i ON i.oid = ix.indexrelid
+       JOIN pg_class t ON t.oid = ix.indrelid
+       JOIN LATERAL unnest(ix.indkey) WITH ORDINALITY AS k(attnum, ord) ON true
+       JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum
+      WHERE t.relname = $1
+        AND NOT EXISTS (SELECT 1 FROM pg_constraint c WHERE c.conindid = ix.indexrelid)
+      GROUP BY i.relname, ix.indisunique, ix.indpred`,
+    [table]
+  );
+  return rows.filter((row) => !row.is_partial).map((row) => ({
+    name: row.name,
+    columns: row.columns.split(","),
+    unique: row.is_unique === true,
+    where: null
+  }));
+}
 function describeKind(type) {
   if (type.kind !== "array") return type.kind;
   return `${type.meta.element ? describeKind(type.meta.element) : "unknown"}[]`;
@@ -1564,6 +3191,7 @@ async function checkDriftPostgres(driver, models) {
         );
       }
     }
+    issues.push(...indexDrift(tableName, actualTable, expectedTable));
   }
   for (const tableName of Object.keys(actual.tables)) {
     if (!expected.tables[tableName]) {
@@ -1641,7 +3269,22 @@ function applyOperation(schema, op) {
         tables[op.table] = op.constraint.type === "unique" ? {
           ...t,
           uniqueConstraints: [...t.uniqueConstraints, op.constraint.constraint]
-        } : { ...t, foreignKeys: [...t.foreignKeys, op.constraint.constraint] };
+        } : op.constraint.type === "check" ? { ...t, checks: [...t.checks, op.constraint.constraint] } : { ...t, foreignKeys: [...t.foreignKeys, op.constraint.constraint] };
+      }
+      break;
+    }
+    case "create_index": {
+      const t = tables[op.table];
+      if (t) tables[op.table] = { ...t, indexes: [...t.indexes, op.index] };
+      break;
+    }
+    case "drop_index": {
+      const t = tables[op.table];
+      if (t) {
+        tables[op.table] = {
+          ...t,
+          indexes: t.indexes.filter((i) => i.name !== op.index.name)
+        };
       }
       break;
     }
@@ -1652,7 +3295,7 @@ function applyOperation(schema, op) {
         tables[op.table] = op.constraint.type === "unique" ? {
           ...t,
           uniqueConstraints: t.uniqueConstraints.filter((u) => u.name !== dropName)
-        } : {
+        } : op.constraint.type === "check" ? { ...t, checks: t.checks.filter((c) => c.name !== dropName) } : {
           ...t,
           foreignKeys: t.foreignKeys.filter((f) => f.name !== dropName)
         };