prisma-sql 1.48.0 → 1.49.0

package/dist/index.cjs

@@ -43,6 +43,7 @@ var __async = (__this, __arguments, generator) => {
 };
 
 // src/builder/shared/constants.ts
+var IS_PRODUCTION = process.env.NODE_ENV === "production";
 var SQL_SEPARATORS = Object.freeze({
   FIELD_LIST: ", ",
   CONDITION_AND: " AND ",
@@ -485,6 +486,15 @@ function createError(message, ctx, code = "VALIDATION_ERROR") {
 
 // src/builder/shared/model-field-cache.ts
 var MODEL_CACHE = /* @__PURE__ */ new WeakMap();
+function quote(id) {
+  const needsQuoting2 = !/^[a-z_][a-z0-9_]*$/.test(id) || /^(select|from|where|having|order|group|limit|offset|join|inner|left|right|outer|cross|full|and|or|not|by|as|on|union|intersect|except|case|when|then|else|end|user|users|table|column|index|values|in|like|between|is|exists|null|true|false|all|any|some|update|insert|delete|create|drop|alter|truncate|grant|revoke|exec|execute)$/i.test(
+    id
+  );
+  if (needsQuoting2) {
+    return `"${id.replace(/"/g, '""')}"`;
+  }
+  return id;
+}
 function ensureFullCache(model) {
   let cache = MODEL_CACHE.get(model);
   if (!cache) {
@@ -492,6 +502,8 @@ function ensureFullCache(model) {
     const scalarFields = /* @__PURE__ */ new Set();
     const relationFields = /* @__PURE__ */ new Set();
     const columnMap = /* @__PURE__ */ new Map();
+    const fieldByName = /* @__PURE__ */ new Map();
+    const quotedColumns = /* @__PURE__ */ new Map();
     for (const f of model.fields) {
       const info = {
         name: f.name,
@@ -501,14 +513,24 @@ function ensureFullCache(model) {
         isRequired: !!f.isRequired
       };
       fieldInfo.set(f.name, info);
+      fieldByName.set(f.name, f);
       if (info.isRelation) {
         relationFields.add(f.name);
       } else {
         scalarFields.add(f.name);
-        columnMap.set(f.name, info.dbName);
+        const dbName = info.dbName;
+        columnMap.set(f.name, dbName);
+        quotedColumns.set(f.name, quote(dbName));
       }
     }
-    cache = { fieldInfo, scalarFields, relationFields, columnMap };
+    cache = {
+      fieldInfo,
+      scalarFields,
+      relationFields,
+      columnMap,
+      fieldByName,
+      quotedColumns
+    };
     MODEL_CACHE.set(model, cache);
   }
   return cache;
@@ -525,6 +547,9 @@ function getRelationFieldSet(model) {
 function getColumnMap(model) {
   return ensureFullCache(model).columnMap;
 }
+function getQuotedColumn(model, fieldName) {
+  return ensureFullCache(model).quotedColumns.get(fieldName);
+}
 
 // src/builder/shared/validators/sql-validators.ts
 function isValidWhereClause(clause) {
@@ -540,6 +565,7 @@ function sqlPreview(sql) {
   return `${s.slice(0, 160)}...`;
 }
 function validateSelectQuery(sql) {
+  if (IS_PRODUCTION) return;
   if (!hasValidContent(sql)) {
     throw new Error("CRITICAL: Generated empty SQL query");
   }
@@ -598,6 +624,7 @@ function assertNoGapsDollar(scan, rangeMin, rangeMax, sql) {
   }
 }
 function validateParamConsistency(sql, params) {
+  if (IS_PRODUCTION) return;
   const paramLen = params.length;
   const scan = scanDollarPlaceholders(sql, paramLen);
   if (paramLen === 0) {
@@ -634,6 +661,7 @@ function countQuestionMarkPlaceholders(sql) {
   return count;
 }
 function validateQuestionMarkConsistency(sql, params) {
+  if (IS_PRODUCTION) return;
   const expected = params.length;
   const found = countQuestionMarkPlaceholders(sql);
   if (expected !== found) {
@@ -643,6 +671,7 @@ function validateQuestionMarkConsistency(sql, params) {
   }
 }
 function validateParamConsistencyByDialect(sql, params, dialect) {
+  if (IS_PRODUCTION) return;
   if (dialect === "postgres") {
     validateParamConsistency(sql, params);
     return;
@@ -804,7 +833,7 @@ function assertSafeQualifiedName(tableRef) {
     }
   }
 }
-function quote(id) {
+function quote2(id) {
   if (isEmptyString(id)) {
     throw new Error("quote: identifier is required and cannot be empty");
   }
@@ -824,17 +853,14 @@ function resolveColumnName(model, fieldName) {
   return columnMap.get(fieldName) || fieldName;
 }
 function quoteColumn(model, fieldName) {
-  return quote(resolveColumnName(model, fieldName));
+  if (!model) return quote2(fieldName);
+  const cached = getQuotedColumn(model, fieldName);
+  return cached || quote2(fieldName);
 }
 function col(alias, field, model) {
-  if (isEmptyString(alias)) {
-    throw new Error("col: alias is required and cannot be empty");
-  }
-  if (isEmptyString(field)) {
-    throw new Error("col: field is required and cannot be empty");
-  }
-  const columnName = resolveColumnName(model, field);
-  return `${alias}.${quote(columnName)}`;
+  const columnName = model ? getColumnMap(model).get(field) || field : field;
+  const quoted = model ? getQuotedColumn(model, field) || quote2(columnName) : quote2(columnName);
+  return alias + "." + quoted;
 }
 function colWithAlias(alias, field, model) {
   if (isEmptyString(alias)) {
@@ -844,9 +870,9 @@ function colWithAlias(alias, field, model) {
     throw new Error("colWithAlias: field is required and cannot be empty");
   }
   const columnName = resolveColumnName(model, field);
-  const columnRef = `${alias}.${quote(columnName)}`;
+  const columnRef = alias + "." + (model ? getQuotedColumn(model, field) || quote2(columnName) : quote2(columnName));
   if (columnName !== field) {
-    return `${columnRef} AS ${quote(field)}`;
+    return columnRef + " AS " + quote2(field);
   }
   return columnRef;
 }
@@ -869,7 +895,7 @@ function buildTableReference(schemaName, tableName, dialect) {
   }
   const d = dialect != null ? dialect : "postgres";
   if (d === "sqlite") {
-    return quote(tableName);
+    return quote2(tableName);
   }
   if (isEmptyString(schemaName)) {
     throw new Error(
@@ -1197,6 +1223,7 @@ function assertNumericField(model, fieldName, context) {
 
 // src/builder/pagination.ts
 var MAX_LIMIT_OFFSET = 2147483647;
+var ORDER_BY_ALLOWED_KEYS = /* @__PURE__ */ new Set(["sort", "nulls"]);
 function parseDirectionRaw(raw, errorLabel) {
   const s = String(raw).toLowerCase();
   if (s === "asc" || s === "desc") return s;
@@ -1215,9 +1242,8 @@ function requireOrderByObject(v, errorPrefix) {
   return v;
 }
 function assertAllowedOrderByKeys(obj, fieldName) {
-  const allowed = /* @__PURE__ */ new Set(["sort", "nulls"]);
   for (const k of Object.keys(obj)) {
-    if (!allowed.has(k)) {
+    if (!ORDER_BY_ALLOWED_KEYS.has(k)) {
       throw new Error(
         fieldName ? `Unsupported orderBy key '${k}' for field '${fieldName}'` : `Unsupported orderBy key '${k}'`
       );
@@ -1284,17 +1310,17 @@ function buildOrderByFragment(entries, alias, dialect, model) {
     const c = col(alias, e.field, model);
     if (dialect === "postgres") {
       const nulls = isNotNullish(e.nulls) ? ` NULLS ${e.nulls.toUpperCase()}` : "";
-      out.push(`${c} ${dir}${nulls}`);
+      out.push(c + " " + dir + nulls);
       continue;
     }
     if (isNotNullish(e.nulls)) {
       const isNullExpr = `(${c} IS NULL)`;
       const nullRankDir = e.nulls === "first" ? "DESC" : "ASC";
-      out.push(`${isNullExpr} ${nullRankDir}`);
-      out.push(`${c} ${dir}`);
+      out.push(isNullExpr + " " + nullRankDir);
+      out.push(c + " " + dir);
       continue;
     }
-    out.push(`${c} ${dir}`);
+    out.push(c + " " + dir);
   }
   return out.join(SQL_SEPARATORS.ORDER_BY);
 }
@@ -1303,79 +1329,47 @@ function defaultNullsFor(dialect, direction) {
   return direction === "asc" ? "first" : "last";
 }
 function ensureCursorFieldsInOrder(orderEntries, cursorEntries) {
-  const existing = /* @__PURE__ */ new Map();
-  for (const e of orderEntries) existing.set(e.field, e);
-  const out = [...orderEntries];
-  for (const [field] of cursorEntries) {
+  if (cursorEntries.length === 0) return orderEntries;
+  const existing = /* @__PURE__ */ new Set();
+  for (let i = 0; i < orderEntries.length; i++)
+    existing.add(orderEntries[i].field);
+  let out = null;
+  for (let i = 0; i < cursorEntries.length; i++) {
+    const field = cursorEntries[i][0];
     if (!existing.has(field)) {
+      if (!out) out = orderEntries.slice();
       out.push({ field, direction: "asc" });
-      existing.set(field, out[out.length - 1]);
+      existing.add(field);
     }
   }
-  return out;
+  return out != null ? out : orderEntries;
 }
 function buildCursorFilterParts(cursor, cursorAlias, params, model) {
-  const entries = Object.entries(cursor);
-  if (entries.length === 0)
-    throw new Error("cursor must have at least one field");
-  const placeholdersByField = /* @__PURE__ */ new Map();
   const parts = [];
-  for (const [field, value] of entries) {
-    const c = `${cursorAlias}.${quoteColumn(model, field)}`;
+  for (const field in cursor) {
+    if (!Object.prototype.hasOwnProperty.call(cursor, field)) continue;
+    const value = cursor[field];
+    const c = cursorAlias + "." + quoteColumn(model, field);
     if (value === null) {
-      parts.push(`${c} IS NULL`);
+      parts.push(c + " IS NULL");
       continue;
     }
     const ph = addAutoScoped(params, value, `cursor.filter.${field}`);
-    placeholdersByField.set(field, ph);
-    parts.push(`${c} = ${ph}`);
+    parts.push(c + " = " + ph);
   }
   return {
-    whereSql: parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`,
-    placeholdersByField
+    whereSql: parts.length === 1 ? parts[0] : "(" + parts.join(" AND ") + ")"
   };
 }
-function buildCursorEqualityExpr(columnExpr, valueExpr) {
-  return `((${valueExpr} IS NULL AND ${columnExpr} IS NULL) OR (${valueExpr} IS NOT NULL AND ${columnExpr} = ${valueExpr}))`;
+function buildCursorEqualityExpr(columnExpr, cursorField) {
+  return `((${cursorField} IS NULL AND ${columnExpr} IS NULL) OR (${cursorField} IS NOT NULL AND ${columnExpr} = ${cursorField}))`;
 }
-function buildCursorInequalityExpr(columnExpr, direction, nulls, valueExpr) {
+function buildCursorInequalityExpr(columnExpr, direction, nulls, cursorField) {
   const op = direction === "asc" ? ">" : "<";
   if (nulls === "first") {
-    return `(CASE WHEN ${valueExpr} IS NULL THEN (${columnExpr} IS NOT NULL) ELSE (${columnExpr} ${op} ${valueExpr}) END)`;
-  }
-  return `(CASE WHEN ${valueExpr} IS NULL THEN 0=1 ELSE ((${columnExpr} ${op} ${valueExpr}) OR (${columnExpr} IS NULL)) END)`;
-}
-function buildOuterCursorMatch(cursor, outerAlias, placeholdersByField, params, model) {
-  const parts = [];
-  for (const [field, value] of Object.entries(cursor)) {
-    const c = col(outerAlias, field, model);
-    if (value === null) {
-      parts.push(`${c} IS NULL`);
-      continue;
-    }
-    const existing = placeholdersByField.get(field);
-    if (typeof existing === "string" && existing.length > 0) {
-      parts.push(`${c} = ${existing}`);
-      continue;
-    }
-    const ph = addAutoScoped(params, value, `cursor.outerMatch.${field}`);
-    parts.push(`${c} = ${ph}`);
-  }
-  return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
-}
-function buildOrderEntries(orderBy) {
-  const normalized = normalizeOrderByInput(orderBy, parseOrderByValue);
-  const entries = [];
-  for (const item of normalized) {
-    for (const [field, value] of Object.entries(item)) {
-      if (typeof value === "string") {
-        entries.push({ field, direction: value });
-      } else {
-        entries.push({ field, direction: value.direction, nulls: value.nulls });
-      }
-    }
+    return `(CASE WHEN ${cursorField} IS NULL THEN (${columnExpr} IS NOT NULL) ELSE (${columnExpr} ${op} ${cursorField}) END)`;
   }
-  return entries;
+  return `(CASE WHEN ${cursorField} IS NULL THEN 0=1 ELSE ((${columnExpr} ${op} ${cursorField}) OR (${columnExpr} IS NULL)) END)`;
 }
 function buildCursorCteSelectList(cursorEntries, orderEntries, model) {
   const seen = /* @__PURE__ */ new Set();
@@ -1397,8 +1391,7 @@ function buildCursorCteSelectList(cursorEntries, orderEntries, model) {
 }
 function truncateIdent(name, maxLen) {
   const s = String(name);
-  if (s.length <= maxLen) return s;
-  return s.slice(0, maxLen);
+  return s.length <= maxLen ? s : s.slice(0, maxLen);
 }
 function buildCursorNames(outerAlias) {
   const maxLen = 63;
@@ -1415,15 +1408,25 @@ function buildCursorNames(outerAlias) {
 }
 function assertCursorAndOrderFieldsScalar(model, cursor, orderEntries) {
   if (!model) return;
-  for (const k of Object.keys(cursor)) assertScalarField(model, k, "cursor");
-  for (const e of orderEntries) assertScalarField(model, e.field, "orderBy");
+  for (const k in cursor) {
+    if (!Object.prototype.hasOwnProperty.call(cursor, k)) continue;
+    assertScalarField(model, k, "cursor");
+  }
+  for (const e of orderEntries) {
+    assertScalarField(model, e.field, "orderBy");
+  }
 }
 function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect, model) {
   var _a;
   assertSafeTableRef(tableName);
   assertSafeAlias(alias);
   const d = dialect != null ? dialect : getGlobalDialect();
-  const cursorEntries = Object.entries(cursor);
+  const cursorEntries = [];
+  for (const k in cursor) {
+    if (Object.prototype.hasOwnProperty.call(cursor, k)) {
+      cursorEntries.push([k, cursor[k]]);
+    }
+  }
   if (cursorEntries.length === 0)
     throw new Error("cursor must have at least one field");
   const { cteName, srcAlias } = buildCursorNames(alias);
@@ -1444,48 +1447,51 @@ function buildCursorCondition(cursor, orderBy, tableName, alias, params, dialect
     orderEntries = ensureCursorFieldsInOrder(orderEntries, cursorEntries);
   }
   assertCursorAndOrderFieldsScalar(model, cursor, orderEntries);
-  const { whereSql: cursorWhereSql, placeholdersByField } = buildCursorFilterParts(cursor, srcAlias, params, model);
+  const { whereSql: cursorWhereSql } = buildCursorFilterParts(
+    cursor,
+    srcAlias,
+    params,
+    model
+  );
   const cursorOrderBy = orderEntries.map(
-    (e) => `${srcAlias}.${quoteColumn(model, e.field)} ${e.direction.toUpperCase()}`
+    (e) => srcAlias + "." + quoteColumn(model, e.field) + " " + e.direction.toUpperCase()
   ).join(", ");
   const selectList = buildCursorCteSelectList(
     cursorEntries,
     orderEntries,
     model
   );
-  const cte = `${cteName} AS (
-    SELECT ${selectList} FROM ${tableName} ${srcAlias}
-    WHERE ${cursorWhereSql}
-    ORDER BY ${cursorOrderBy}
-    LIMIT 1
-  )`;
-  const existsExpr = `EXISTS (SELECT 1 FROM ${cteName})`;
-  const outerCursorMatch = buildOuterCursorMatch(
-    cursor,
-    alias,
-    placeholdersByField,
-    params,
-    model
-  );
-  const getValueExpr = (field) => `(SELECT ${quoteColumn(model, field)} FROM ${cteName})`;
+  const cte = cteName + " AS (\n    SELECT " + selectList + " FROM " + tableName + " " + srcAlias + "\n    WHERE " + cursorWhereSql + "\n    ORDER BY " + cursorOrderBy + "\n    LIMIT 1\n  )";
+  const existsExpr = "EXISTS (SELECT 1 FROM " + cteName + ")";
   const orClauses = [];
   for (let level = 0; level < orderEntries.length; level++) {
     const andParts = [];
     for (let i = 0; i < level; i++) {
       const e2 = orderEntries[i];
       const c2 = col(alias, e2.field, model);
-      const v2 = getValueExpr(e2.field);
-      andParts.push(buildCursorEqualityExpr(c2, v2));
+      const cursorField2 = cteName + "." + quoteColumn(model, e2.field);
+      andParts.push(buildCursorEqualityExpr(c2, cursorField2));
     }
     const e = orderEntries[level];
     const c = col(alias, e.field, model);
-    const v = getValueExpr(e.field);
+    const cursorField = cteName + "." + quoteColumn(model, e.field);
     const nulls = (_a = e.nulls) != null ? _a : defaultNullsFor(d, e.direction);
-    andParts.push(buildCursorInequalityExpr(c, e.direction, nulls, v));
-    orClauses.push(`(${andParts.join(SQL_SEPARATORS.CONDITION_AND)})`);
+    andParts.push(buildCursorInequalityExpr(c, e.direction, nulls, cursorField));
+    orClauses.push("(" + andParts.join(SQL_SEPARATORS.CONDITION_AND) + ")");
   }
   const exclusive = orClauses.join(SQL_SEPARATORS.CONDITION_OR);
-  const condition = `(${existsExpr} ${SQL_SEPARATORS.CONDITION_AND} ((${exclusive})${SQL_SEPARATORS.CONDITION_OR}(${outerCursorMatch})))`;
+  const outerMatchParts = [];
+  for (const [field, value] of cursorEntries) {
+    const c = col(alias, field, model);
+    if (value === null) {
+      outerMatchParts.push(c + " IS NULL");
+      continue;
+    }
+    const ph = addAutoScoped(params, value, `cursor.outerMatch.${field}`);
+    outerMatchParts.push(c + " = " + ph);
+  }
+  const outerCursorMatch = outerMatchParts.length === 1 ? outerMatchParts[0] : "(" + outerMatchParts.join(SQL_SEPARATORS.CONDITION_AND) + ")";
+  const condition = "(" + existsExpr + SQL_SEPARATORS.CONDITION_AND + "((" + exclusive + ")" + SQL_SEPARATORS.CONDITION_OR + "(" + outerCursorMatch + ")))";
   return { cte, condition };
 }
 function buildOrderBy(orderBy, alias, dialect, model) {
@@ -1538,6 +1544,22 @@ function getPaginationParams(method, args) {
   }
   return {};
 }
+function buildOrderEntries(orderBy) {
+  const normalized = normalizeOrderByInput(orderBy, parseOrderByValue);
+  const entries = [];
+  for (const item of normalized) {
+    for (const field in item) {
+      if (!Object.prototype.hasOwnProperty.call(item, field)) continue;
+      const value = item[field];
+      if (typeof value === "string") {
+        entries.push({ field, direction: value });
+      } else {
+        entries.push({ field, direction: value.direction, nulls: value.nulls });
+      }
+    }
+  }
+  return entries;
+}
 function buildNotComposite(expr, val, params, dialect, buildOp, separator) {
   const entries = Object.entries(val).filter(
     ([k, v]) => k !== "mode" && v !== void 0
@@ -2008,7 +2030,7 @@ function buildListRelationFilters(args) {
       ) || relModel.fields.find((f) => !f.isRelation && f.name === "id");
       if (checkField) {
         const leftJoinSql = `LEFT JOIN ${relTable} ${relAlias} ON ${join}`;
-        const whereClause = `${relAlias}.${quote(checkField.name)} IS NULL`;
+        const whereClause = `${relAlias}.${quote2(checkField.name)} IS NULL`;
         return Object.freeze({
           clause: whereClause,
           joins: freezeJoins([leftJoinSql])
@@ -2459,11 +2481,24 @@ function buildOperator(expr, op, val, ctx, mode, fieldType) {
 // src/builder/shared/alias-generator.ts
 function toSafeSqlIdentifier(input) {
   const raw = String(input);
-  const cleaned = raw.replace(/\W/g, "_");
-  const startsOk = /^[a-zA-Z_]/.test(cleaned);
-  const base = startsOk ? cleaned : `_${cleaned}`;
-  const fallback = base.length > 0 ? base : "_t";
-  const lowered = fallback.toLowerCase();
+  const n = raw.length;
+  let out = "";
+  for (let i = 0; i < n; i++) {
+    const c = raw.charCodeAt(i);
+    const isAZ = c >= 65 && c <= 90 || c >= 97 && c <= 122;
+    const is09 = c >= 48 && c <= 57;
+    const isUnderscore = c === 95;
+    if (isAZ || is09 || isUnderscore) {
+      out += raw[i];
+    } else {
+      out += "_";
+    }
+  }
+  if (out.length === 0) out = "_t";
+  const c0 = out.charCodeAt(0);
+  const startsOk = c0 >= 65 && c0 <= 90 || c0 >= 97 && c0 <= 122 || c0 === 95;
+  if (!startsOk) out = `_${out}`;
+  const lowered = out.toLowerCase();
   return ALIAS_FORBIDDEN_KEYWORDS.has(lowered) ? `_${lowered}` : lowered;
 }
 function createAliasGenerator(maxAliases = 1e4) {
@@ -2566,14 +2601,16 @@ function validateState(params, mappings, index) {
 }
 function createStoreInternal(startIndex, initialParams = [], initialMappings = []) {
   let index = startIndex;
-  const params = [...initialParams];
-  const mappings = [...initialMappings];
+  const params = initialParams.length > 0 ? [...initialParams] : [];
+  const mappings = initialMappings.length > 0 ? [...initialMappings] : [];
   const dynamicNameToIndex = /* @__PURE__ */ new Map();
-  for (const m of initialMappings) {
+  for (const m of mappings) {
     if (typeof m.dynamicName === "string") {
       dynamicNameToIndex.set(m.dynamicName.trim(), m.index);
     }
   }
+  let dirty = true;
+  let cachedSnapshot = null;
   function assertCanAdd() {
     if (index > MAX_PARAM_INDEX) {
       throw new Error(
@@ -2581,6 +2618,9 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
       );
     }
   }
+  function format(position) {
+    return `$${position}`;
+  }
   function normalizeDynamicName(dynamicName) {
     const dn = dynamicName.trim();
     if (dn.length === 0) {
@@ -2588,20 +2628,16 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
     }
     return dn;
   }
-  function format(position) {
-    return `$${position}`;
-  }
   function addDynamic(dynamicName) {
     const dn = normalizeDynamicName(dynamicName);
     const existing = dynamicNameToIndex.get(dn);
-    if (existing !== void 0) {
-      return format(existing);
-    }
+    if (existing !== void 0) return format(existing);
     const position = index;
     dynamicNameToIndex.set(dn, position);
     params.push(void 0);
     mappings.push({ index: position, dynamicName: dn });
     index++;
+    dirty = true;
     return format(position);
   }
   function addStatic(value) {
@@ -2610,6 +2646,7 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
     params.push(normalizedValue);
     mappings.push({ index: position, value: normalizedValue });
     index++;
+    dirty = true;
     return format(position);
   }
   function add(value, dynamicName) {
@@ -2624,11 +2661,15 @@ function createStoreInternal(startIndex, initialParams = [], initialMappings = [
     return add(value);
   }
   function snapshot() {
-    return Object.freeze({
+    if (!dirty && cachedSnapshot) return cachedSnapshot;
+    const snap = {
       index,
-      params: Object.freeze([...params]),
-      mappings: Object.freeze([...mappings])
-    });
+      params,
+      mappings
+    };
+    cachedSnapshot = snap;
+    dirty = false;
+    return snap;
   }
   return {
     add,
@@ -2837,7 +2878,7 @@ function getRelationTableReference(relModel, dialect) {
     dialect
   );
 }
-function resolveRelationOrThrow(model, schemas, relName) {
+function resolveRelationOrThrow(model, schemas, schemaByName, relName) {
   const field = model.fields.find((f) => f.name === relName);
   if (!isNotNullish(field)) {
     throw new Error(
@@ -2849,10 +2890,16 @@ function resolveRelationOrThrow(model, schemas, relName) {
       `Invalid relation metadata for '${relName}' on model ${model.name}. This usually indicates a schema parsing error (missing foreignKey/references).`
     );
   }
-  const relModel = schemas.find((m) => m.name === field.relatedModel);
+  const relatedModelName = field.relatedModel;
+  if (!isNotNullish(relatedModelName) || String(relatedModelName).trim().length === 0) {
+    throw new Error(
+      `Relation '${relName}' on model ${model.name} is missing relatedModel metadata.`
+    );
+  }
+  const relModel = schemaByName.get(relatedModelName);
   if (!isNotNullish(relModel)) {
     throw new Error(
-      `Relation '${relName}' on model ${model.name} references missing model '${field.relatedModel}'.`
+      `Relation '${relName}' on model ${model.name} references missing model '${relatedModelName}'.`
     );
   }
   return { field, relModel };
@@ -2971,6 +3018,7 @@ function buildSelectWithNestedIncludes(relArgs, relModel, relAlias, ctx) {
     relArgs,
     relModel,
     ctx.schemas,
+    ctx.schemaByName,
     relAlias,
     ctx.aliasGen,
     ctx.params,
@@ -3159,7 +3207,7 @@ function buildSingleInclude(relName, relArgs, field, relModel, ctx) {
     ctx
   });
 }
-function buildIncludeSqlInternal(args, model, schemas, parentAlias, aliasGen, params, dialect, visitPath = [], depth = 0, stats) {
+function buildIncludeSqlInternal(args, model, schemas, schemaByName, parentAlias, aliasGen, params, dialect, visitPath = [], depth = 0, stats) {
   if (!stats) stats = { totalIncludes: 0, totalSubqueries: 0, maxDepth: 0 };
   if (depth > MAX_INCLUDE_DEPTH) {
     throw new Error(
@@ -3183,7 +3231,12 @@ function buildIncludeSqlInternal(args, model, schemas, parentAlias, aliasGen, pa
         `Query complexity limit exceeded: ${stats.totalSubqueries} subqueries generated. Maximum allowed: ${MAX_TOTAL_SUBQUERIES}. This indicates exponential include nesting. Stats: depth=${stats.maxDepth}, includes=${stats.totalIncludes}. Path: ${visitPath.join(" -> ")}. Simplify your include structure or split into multiple queries.`
       );
     }
-    const resolved = resolveRelationOrThrow(model, schemas, relName);
+    const resolved = resolveRelationOrThrow(
+      model,
+      schemas,
+      schemaByName,
+      relName
+    );
     const relationPath = `${model.name}.${relName}`;
     const currentPath = [...visitPath, relationPath];
     if (visitPath.includes(relationPath)) {
@@ -3203,6 +3256,7 @@ function buildIncludeSqlInternal(args, model, schemas, parentAlias, aliasGen, pa
       buildSingleInclude(relName, relArgs, resolved.field, resolved.relModel, {
         model,
         schemas,
+        schemaByName,
         parentAlias,
         aliasGen,
         dialect,
@@ -3222,10 +3276,13 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
     totalSubqueries: 0,
     maxDepth: 0
   };
+  const schemaByName = /* @__PURE__ */ new Map();
+  for (const m of schemas) schemaByName.set(m.name, m);
   return buildIncludeSqlInternal(
     args,
     model,
     schemas,
+    schemaByName,
     parentAlias,
     aliasGen,
     params,
@@ -3235,7 +3292,7 @@ function buildIncludeSql(args, model, schemas, parentAlias, params, dialect) {
     stats
   );
 }
-function resolveCountRelationOrThrow(relName, model, schemas) {
+function resolveCountRelationOrThrow(relName, model, schemas, schemaByName) {
   const relationSet = getRelationFieldSet(model);
   if (!relationSet.has(relName)) {
     throw new Error(
@@ -3252,10 +3309,16 @@ function resolveCountRelationOrThrow(relName, model, schemas) {
       `_count.${relName} has invalid relation metadata on model ${model.name}`
     );
   }
-  const relModel = schemas.find((m) => m.name === field.relatedModel);
+  const relatedModelName = field.relatedModel;
+  if (!isNotNullish(relatedModelName) || String(relatedModelName).trim().length === 0) {
+    throw new Error(
+      `_count.${relName} is missing relatedModel metadata on model ${model.name}`
+    );
+  }
+  const relModel = schemaByName.get(relatedModelName);
   if (!relModel) {
     throw new Error(
-      `Related model '${field.relatedModel}' not found for _count.${relName}`
+      `Related model '${relatedModelName}' not found for _count.${relName}`
     );
   }
   return { field, relModel };
@@ -3341,9 +3404,16 @@ function buildRelationCountSql(countSelect, model, schemas, parentAlias, _params
   const joins = [];
   const pairs = [];
   const aliasGen = createAliasGenerator();
+  const schemaByName = /* @__PURE__ */ new Map();
+  for (const m of schemas) schemaByName.set(m.name, m);
   for (const [relName, shouldCount] of Object.entries(countSelect)) {
     if (!shouldCount) continue;
-    const resolved = resolveCountRelationOrThrow(relName, model, schemas);
+    const resolved = resolveCountRelationOrThrow(
+      relName,
+      model,
+      schemas,
+      schemaByName
+    );
     const built = buildCountJoinAndPair({
       relName,
       field: resolved.field,
@@ -3359,35 +3429,36 @@ function buildRelationCountSql(countSelect, model, schemas, parentAlias, _params
   return { joins, jsonPairs: pairs.join(SQL_SEPARATORS.FIELD_LIST) };
 }
 
-// src/builder/select/assembly.ts
-var ALIAS_CAPTURE = "([A-Za-z_][A-Za-z0-9_]*)";
-var COLUMN_PART = '(?:"([^"]+)"|([a-z_][a-z0-9_]*))';
-var AS_PART = `(?:\\s+AS\\s+${COLUMN_PART})?`;
-var SIMPLE_COLUMN_PATTERN = `^${ALIAS_CAPTURE}\\.${COLUMN_PART}${AS_PART}$`;
-var SIMPLE_COLUMN_RE = new RegExp(SIMPLE_COLUMN_PATTERN, "i");
+// src/builder/shared/string-builder.ts
 function joinNonEmpty(parts, sep) {
-  return parts.filter((s) => s.trim().length > 0).join(sep);
+  let result = "";
+  for (const p of parts) {
+    if (p) {
+      if (result) result += sep;
+      result += p;
+    }
+  }
+  return result;
 }
 function buildWhereSql(conditions) {
   if (!isNonEmptyArray(conditions)) return "";
-  const parts = [
-    SQL_TEMPLATES.WHERE,
-    conditions.join(SQL_SEPARATORS.CONDITION_AND)
-  ];
-  return ` ${parts.join(" ")}`;
+  return " " + SQL_TEMPLATES.WHERE + " " + conditions.join(SQL_SEPARATORS.CONDITION_AND);
 }
 function buildJoinsSql(...joinGroups) {
   const all = [];
   for (const g of joinGroups) {
-    if (isNonEmptyArray(g)) all.push(...g);
+    if (isNonEmptyArray(g)) {
+      for (const j of g) all.push(j);
+    }
   }
-  return all.length > 0 ? ` ${all.join(" ")}` : "";
+  return all.length > 0 ? " " + all.join(" ") : "";
 }
 function buildSelectList(baseSelect, extraCols) {
   const base = baseSelect.trim();
   const extra = extraCols.trim();
-  if (base && extra) return `${base}${SQL_SEPARATORS.FIELD_LIST}${extra}`;
-  return base || extra;
+  if (!base) return extra;
+  if (!extra) return base;
+  return base + SQL_SEPARATORS.FIELD_LIST + extra;
 }
 function finalizeSql(sql, params, dialect) {
   const snapshot = params.snapshot();
@@ -3397,38 +3468,128 @@ function finalizeSql(sql, params, dialect) {
     snapshot.params,
     dialect === "sqlite" ? "postgres" : dialect
   );
-  return Object.freeze({
+  return {
     sql,
     params: snapshot.params,
-    paramMappings: Object.freeze(snapshot.mappings)
-  });
+    paramMappings: snapshot.mappings
+  };
 }
 function parseSimpleScalarSelect(select, fromAlias) {
-  var _a, _b, _c, _d;
   const raw = select.trim();
   if (raw.length === 0) return [];
+  const fromLower = fromAlias.toLowerCase();
   const parts = raw.split(SQL_SEPARATORS.FIELD_LIST);
   const names = [];
-  for (const part of parts) {
-    const p = part.trim();
-    const m = p.match(SIMPLE_COLUMN_RE);
-    if (!m) {
+  const isIdent = (s) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(s);
+  const readIdentOrQuoted = (s, start) => {
+    const n = s.length;
+    if (start >= n) return { text: "", next: start, quoted: false };
+    if (s.charCodeAt(start) === 34) {
+      let i2 = start + 1;
+      let out = "";
+      let saw = false;
+      while (i2 < n) {
+        const c = s.charCodeAt(i2);
+        if (c === 34) {
+          const next = i2 + 1;
+          if (next < n && s.charCodeAt(next) === 34) {
+            out += '"';
+            saw = true;
+            i2 += 2;
+            continue;
+          }
+          if (!saw)
+            throw new Error(
+              `sqlite distinct emulation: empty quoted identifier in: ${s}`
+            );
+          return { text: out, next: i2 + 1, quoted: true };
+        }
+        out += s[i2];
+        saw = true;
+        i2++;
+      }
       throw new Error(
-        `sqlite distinct emulation requires scalar select fields to be simple columns (optionally with AS). Got: ${p}`
+        `sqlite distinct emulation: unterminated quoted identifier in: ${s}`
       );
     }
-    const actualAlias = m[1];
-    if (actualAlias.toLowerCase() !== fromAlias.toLowerCase()) {
+    let i = start;
+    while (i < n) {
+      const c = s.charCodeAt(i);
+      if (c === 32 || c === 9) break;
+      if (c === 46) break;
+      i++;
+    }
+    return { text: s.slice(start, i), next: i, quoted: false };
+  };
+  const skipSpaces = (s, i) => {
+    while (i < s.length) {
+      const c = s.charCodeAt(i);
+      if (c !== 32 && c !== 9) break;
+      i++;
+    }
+    return i;
+  };
+  for (let idx = 0; idx < parts.length; idx++) {
+    const p = parts[idx].trim();
+    if (p.length === 0) continue;
+    let i = 0;
+    i = skipSpaces(p, i);
+    const a = readIdentOrQuoted(p, i);
+    const actualAlias = a.text.toLowerCase();
+    if (!isIdent(a.text)) {
       throw new Error(
-        `Expected alias '${fromAlias}', got '${actualAlias}' in: ${p}`
+        `sqlite distinct emulation requires scalar select fields to be simple columns (alias.column). Got: ${p}`
       );
     }
-    const columnName = ((_b = (_a = m[2]) != null ? _a : m[3]) != null ? _b : "").trim();
-    const outAlias = ((_d = (_c = m[4]) != null ? _c : m[5]) != null ? _d : "").trim();
-    const name = outAlias.length > 0 ? outAlias : columnName;
-    if (name.length === 0) {
+    if (actualAlias !== fromLower) {
+      throw new Error(`Expected alias '${fromAlias}', got '${a.text}' in: ${p}`);
+    }
+    i = a.next;
+    if (i >= p.length || p.charCodeAt(i) !== 46) {
+      throw new Error(
+        `sqlite distinct emulation requires scalar select fields to be simple columns (alias.column). Got: ${p}`
+      );
+    }
+    i++;
+    i = skipSpaces(p, i);
+    const colPart = readIdentOrQuoted(p, i);
+    const columnName = colPart.text.trim();
+    if (columnName.length === 0) {
       throw new Error(`Failed to parse selected column name from: ${p}`);
     }
+    i = colPart.next;
+    i = skipSpaces(p, i);
+    let outAlias = "";
+    if (i < p.length) {
+      const rest = p.slice(i).trim();
+      if (rest.length > 0) {
+        const m = rest.match(/^AS\s+/i);
+        if (!m) {
+          throw new Error(
+            `sqlite distinct emulation requires scalar select fields to be simple columns (optionally with AS). Got: ${p}`
+          );
+        }
+        let j = i;
+        j = skipSpaces(p, j);
+        if (!/^AS\b/i.test(p.slice(j))) {
+          throw new Error(`Failed to parse AS in: ${p}`);
+        }
+        j += 2;
+        j = skipSpaces(p, j);
+        const out = readIdentOrQuoted(p, j);
+        outAlias = out.text.trim();
+        if (outAlias.length === 0) {
+          throw new Error(`Failed to parse output alias from: ${p}`);
+        }
+        j = skipSpaces(p, out.next);
+        if (j !== p.length) {
+          throw new Error(
+            `sqlite distinct emulation requires scalar select fields to be simple columns (optionally with AS). Got: ${p}`
+          );
+        }
+      }
+    }
+    const name = outAlias.length > 0 ? outAlias : columnName;
     names.push(name);
   }
   return names;
@@ -3438,15 +3599,14 @@ function replaceOrderByAlias(orderBy, fromAlias, outerAlias) {
   if (src.length === 0) return orderBy;
   const escaped = src.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   const re = new RegExp(`\\b${escaped}\\.`, "gi");
-  return orderBy.replace(re, `${outerAlias}.`);
+  return orderBy.replace(re, outerAlias + ".");
 }
 function buildDistinctColumns(distinct, fromAlias, model) {
   return distinct.map((f) => col(fromAlias, f, model)).join(SQL_SEPARATORS.FIELD_LIST);
 }
 function buildOutputColumns(scalarNames, includeNames, hasCount) {
-  const outputCols = [...scalarNames, ...includeNames];
-  if (hasCount) outputCols.push("_count");
-  const formatted = outputCols.map((n) => quote(n)).join(SQL_SEPARATORS.FIELD_LIST);
+  const outputCols = hasCount ? [...scalarNames, ...includeNames, "_count"] : [...scalarNames, ...includeNames];
+  const formatted = outputCols.map((n) => quote2(n)).join(SQL_SEPARATORS.FIELD_LIST);
   if (!isNonEmptyString(formatted)) {
     throw new Error("distinct emulation requires at least one output column");
   }
@@ -3457,11 +3617,11 @@ function buildWindowOrder(args) {
   const fromLower = String(fromAlias).toLowerCase();
   const orderFields = baseOrder.split(SQL_SEPARATORS.ORDER_BY).map((s) => s.trim().toLowerCase());
   const hasIdInOrder = orderFields.some(
-    (f) => f.startsWith(`${fromLower}.id `) || f.startsWith(`${fromLower}."id" `)
+    (f) => f.startsWith(fromLower + ".id ") || f.startsWith(fromLower + '."id" ')
   );
   if (hasIdInOrder) return baseOrder;
-  const idTiebreaker = idField ? `, ${col(fromAlias, "id", model)} ASC` : "";
-  return `${baseOrder}${idTiebreaker}`;
+  const idTiebreaker = idField ? ", " + col(fromAlias, "id", model) + " ASC" : "";
+  return baseOrder + idTiebreaker;
 }
 function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
   var _a, _b;
@@ -3478,7 +3638,7 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
     hasCount
   );
   const distinctCols = buildDistinctColumns([...distinct], from.alias, model);
-  const fallbackOrder = [...distinct].map((f) => `${col(from.alias, f, model)} ASC`).join(SQL_SEPARATORS.FIELD_LIST);
+  const fallbackOrder = [...distinct].map((f) => col(from.alias, f, model) + " ASC").join(SQL_SEPARATORS.FIELD_LIST);
   const idField = model.fields.find(
     (f) => f.name === "id" && !f.isRelation
   );
@@ -3489,7 +3649,7 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
     fromAlias: from.alias,
     model
   });
-  const outerOrder = isNonEmptyString(orderBy) ? replaceOrderByAlias(orderBy, from.alias, `"__tp_distinct"`) : replaceOrderByAlias(fallbackOrder, from.alias, `"__tp_distinct"`);
+  const outerOrder = isNonEmptyString(orderBy) ? replaceOrderByAlias(orderBy, from.alias, '"__tp_distinct"') : replaceOrderByAlias(fallbackOrder, from.alias, '"__tp_distinct"');
   const joins = buildJoinsSql(whereJoins, countJoins);
   const conditions = [];
   if (whereClause && whereClause !== "1=1") conditions.push(whereClause);
@@ -3499,7 +3659,7 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
   const innerParts = [
     SQL_TEMPLATES.SELECT,
     innerSelectList + innerComma,
-    `ROW_NUMBER() OVER (PARTITION BY ${distinctCols} ORDER BY ${windowOrder})`,
+    "ROW_NUMBER() OVER (PARTITION BY " + distinctCols + " ORDER BY " + windowOrder + ")",
     SQL_TEMPLATES.AS,
     '"__tp_rn"',
     SQL_TEMPLATES.FROM,
@@ -3508,12 +3668,12 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
   ];
   if (joins) innerParts.push(joins);
   if (whereSql) innerParts.push(whereSql);
-  const inner = innerParts.filter(Boolean).join(" ");
+  const inner = innerParts.join(" ");
   const outerParts = [
     SQL_TEMPLATES.SELECT,
     outerSelectCols,
     SQL_TEMPLATES.FROM,
-    `(${inner})`,
+    "(" + inner + ")",
     SQL_TEMPLATES.AS,
     '"__tp_distinct"',
     SQL_TEMPLATES.WHERE,
@@ -3522,7 +3682,7 @@ function buildSqliteDistinctQuery(spec, selectWithIncludes, countJoins) {
   if (isNonEmptyString(outerOrder)) {
     outerParts.push(SQL_TEMPLATES.ORDER_BY, outerOrder);
   }
-  return outerParts.filter(Boolean).join(" ");
+  return outerParts.join(" ");
 }
 function buildIncludeColumns(spec) {
   var _a, _b;
@@ -3542,7 +3702,7 @@ function buildIncludeColumns(spec) {
         dialect
       );
       if (countBuild.jsonPairs) {
-        countCols = `${jsonBuildObject(countBuild.jsonPairs, dialect)} ${SQL_TEMPLATES.AS} ${quote("_count")}`;
+        countCols = jsonBuildObject(countBuild.jsonPairs, dialect) + " " + SQL_TEMPLATES.AS + " " + quote2("_count");
       }
       countJoins = countBuild.joins;
     }
@@ -3554,8 +3714,8 @@ function buildIncludeColumns(spec) {
   }
   const emptyJson = dialect === "postgres" ? `'[]'::json` : `json('[]')`;
   const includeCols = hasIncludes ? includes.map((inc) => {
-    const expr = inc.isOneToOne ? `(${inc.sql})` : `COALESCE((${inc.sql}), ${emptyJson})`;
-    return `${expr} ${SQL_TEMPLATES.AS} ${quote(inc.name)}`;
+    const expr = inc.isOneToOne ? "(" + inc.sql + ")" : "COALESCE((" + inc.sql + "), " + emptyJson + ")";
+    return expr + " " + SQL_TEMPLATES.AS + " " + quote2(inc.name);
   }).join(SQL_SEPARATORS.FIELD_LIST) : "";
   const allCols = joinNonEmpty(
     [includeCols, countCols],
@@ -3623,7 +3783,7 @@ function withCountJoins(spec, countJoins, whereJoins) {
 function buildPostgresDistinctOnClause(fromAlias, distinct, model) {
   if (!isNonEmptyArray(distinct)) return null;
   const distinctCols = buildDistinctColumns([...distinct], fromAlias, model);
-  return `${SQL_TEMPLATES.DISTINCT_ON} (${distinctCols})`;
+  return SQL_TEMPLATES.DISTINCT_ON + " (" + distinctCols + ")";
 }
 function pushJoinGroups(parts, ...groups) {
   for (const g of groups) {
@@ -3668,9 +3828,7 @@ function constructFinalSql(spec) {
     return finalizeSql(sql2, params, dialect);
   }
   const parts = [];
-  if (cursorCte) {
-    parts.push(`WITH ${cursorCte}`);
-  }
+  if (cursorCte) parts.push("WITH " + cursorCte);
   parts.push(SQL_TEMPLATES.SELECT);
   const distinctOn = dialect === "postgres" ? buildPostgresDistinctOnClause(from.alias, distinct, model) : null;
   if (distinctOn) parts.push(distinctOn);
@@ -3681,6 +3839,10 @@ function constructFinalSql(spec) {
   }
   parts.push(fullSelectList);
   parts.push(SQL_TEMPLATES.FROM, from.table, from.alias);
+  if (cursorCte) {
+    const cteName = cursorCte.split(" AS ")[0].trim();
+    parts.push("CROSS JOIN", cteName);
+  }
   pushJoinGroups(parts, whereJoins, countJoins);
   const conditions = buildConditions(whereClause, cursorClause);
   pushWhere(parts, conditions);
@@ -3903,14 +4065,16 @@ function buildSelectSql(input) {
 }
 
 // src/builder/shared/comparison-builder.ts
-function buildComparisons(expr, filter, params, dialect, builder, excludeKeys = /* @__PURE__ */ new Set(["mode"])) {
+var DEFAULT_EXCLUDE_KEYS = /* @__PURE__ */ new Set(["mode"]);
+function buildComparisons(expr, filter, params, dialect, builder, excludeKeys = DEFAULT_EXCLUDE_KEYS) {
   const out = [];
-  for (const [op, val] of Object.entries(filter)) {
-    if (excludeKeys.has(op) || val === void 0) continue;
+  for (const op in filter) {
+    if (!Object.prototype.hasOwnProperty.call(filter, op)) continue;
+    if (excludeKeys.has(op)) continue;
+    const val = filter[op];
+    if (val === void 0) continue;
     const built = builder(expr, op, val, params, dialect);
-    if (built && built.trim().length > 0) {
-      out.push(built);
-    }
+    if (built && built.trim().length > 0) out.push(built);
   }
   return out;
 }
@@ -3940,6 +4104,13 @@ var HAVING_ALLOWED_OPS = /* @__PURE__ */ new Set([
   Ops.IN,
   Ops.NOT_IN
 ]);
+var HAVING_FIELD_FIRST_AGG_KEYS = Object.freeze([
+  "_count",
+  "_sum",
+  "_avg",
+  "_min",
+  "_max"
+]);
 function isTruthySelection(v) {
   return v === true;
 }
@@ -3958,15 +4129,15 @@ function assertHavingOp(op) {
 }
 function aggExprForField(aggKey, field, alias, model) {
   if (aggKey === "_count") {
-    return field === "_all" ? `COUNT(*)` : `COUNT(${col(alias, field, model)})`;
+    return field === "_all" ? "COUNT(*)" : "COUNT(" + col(alias, field, model) + ")";
   }
   if (field === "_all") {
     throw new Error(`'${aggKey}' does not support '_all'`);
   }
-  if (aggKey === "_sum") return `SUM(${col(alias, field, model)})`;
-  if (aggKey === "_avg") return `AVG(${col(alias, field, model)})`;
-  if (aggKey === "_min") return `MIN(${col(alias, field, model)})`;
-  return `MAX(${col(alias, field, model)})`;
+  if (aggKey === "_sum") return "SUM(" + col(alias, field, model) + ")";
+  if (aggKey === "_avg") return "AVG(" + col(alias, field, model) + ")";
+  if (aggKey === "_min") return "MIN(" + col(alias, field, model) + ")";
+  return "MAX(" + col(alias, field, model) + ")";
 }
 function buildComparisonOp(op) {
   const sqlOp = COMPARISON_OPS[op];
@@ -3993,8 +4164,8 @@ function normalizeLogicalValue2(operator, value) {
   throw new Error(`${operator} must be an object or array of objects in HAVING`);
 }
 function buildNullComparison(expr, op) {
-  if (op === Ops.EQUALS) return `${expr} ${SQL_TEMPLATES.IS_NULL}`;
-  if (op === Ops.NOT) return `${expr} ${SQL_TEMPLATES.IS_NOT_NULL}`;
+  if (op === Ops.EQUALS) return expr + " " + SQL_TEMPLATES.IS_NULL;
+  if (op === Ops.NOT) return expr + " " + SQL_TEMPLATES.IS_NOT_NULL;
   throw new Error(`Operator '${op}' doesn't support null in HAVING`);
 }
 function buildInComparison(expr, op, val, params, dialect) {
@@ -4015,7 +4186,7 @@ function buildInComparison(expr, op, val, params, dialect) {
 function buildBinaryComparison(expr, op, val, params) {
   const sqlOp = buildComparisonOp(op);
   const placeholder = addHavingParam(params, op, val);
-  return `${expr} ${sqlOp} ${placeholder}`;
+  return expr + " " + sqlOp + " " + placeholder;
 }
 function buildSimpleComparison(expr, op, val, params, dialect) {
   assertHavingOp(op);
@@ -4036,20 +4207,21 @@ function buildSimpleComparison(expr, op, val, params, dialect) {
   return buildBinaryComparison(expr, op, val, params);
 }
 function negateClauses(subClauses) {
-  if (subClauses.length === 1) return `${SQL_TEMPLATES.NOT} ${subClauses[0]}`;
-  return `${SQL_TEMPLATES.NOT} (${subClauses.join(SQL_SEPARATORS.CONDITION_AND)})`;
+  if (subClauses.length === 1) return SQL_TEMPLATES.NOT + " " + subClauses[0];
+  return SQL_TEMPLATES.NOT + " (" + subClauses.join(SQL_SEPARATORS.CONDITION_AND) + ")";
 }
 function combineLogical(key, subClauses) {
   if (key === LogicalOps.NOT) return negateClauses(subClauses);
-  return subClauses.join(` ${key} `);
+  return subClauses.join(" " + key + " ");
 }
 function buildHavingNode(node, alias, params, dialect, model) {
   const clauses = [];
-  const entries = Object.entries(node);
-  for (const [key, value] of entries) {
+  for (const key in node) {
+    if (!Object.prototype.hasOwnProperty.call(node, key)) continue;
+    const value = node[key];
     const built = buildHavingEntry(key, value, alias, params, dialect, model);
     for (const c of built) {
-      if (c && c.trim().length > 0) clauses.push(c);
+      if (c && c.length > 0) clauses.push(c);
     }
   }
   return clauses.join(SQL_SEPARATORS.CONDITION_AND);
@@ -4059,7 +4231,7 @@ function buildLogicalClause2(key, value, alias, params, dialect, model) {
   const subClauses = [];
   for (const it of items) {
     const c = buildHavingNode(it, alias, params, dialect, model);
-    if (c && c.trim().length > 0) subClauses.push(`(${c})`);
+    if (c && c.length > 0) subClauses.push("(" + c + ")");
   }
   if (subClauses.length === 0) return "";
   return combineLogical(key, subClauses);
@@ -4084,11 +4256,23 @@ function buildHavingForAggregateFirstShape(aggKey, target, alias, params, dialec
     throw new Error(`HAVING '${aggKey}' must be an object`);
   }
   const out = [];
-  for (const [field, filter] of Object.entries(target)) {
+  const targetObj = target;
+  for (const field in targetObj) {
+    if (!Object.prototype.hasOwnProperty.call(targetObj, field)) continue;
     assertHavingAggTarget(aggKey, field, model);
-    if (!isPlainObject(filter) || Object.keys(filter).length === 0) continue;
+    const filter = targetObj[field];
+    if (!isPlainObject(filter)) continue;
+    const filterObj = filter;
+    let hasAny = false;
+    for (const k in filterObj) {
+      if (Object.prototype.hasOwnProperty.call(filterObj, k)) {
+        hasAny = true;
+        break;
+      }
+    }
+    if (!hasAny) continue;
     const expr = aggExprForField(aggKey, field, alias, model);
-    out.push(...buildHavingOpsForExpr(expr, filter, params, dialect));
+    out.push(...buildHavingOpsForExpr(expr, filterObj, params, dialect));
   }
   return out;
 }
@@ -4099,16 +4283,23 @@ function buildHavingForFieldFirstShape(fieldName, target, alias, params, dialect
   assertScalarField(model, fieldName, "HAVING");
   const out = [];
   const obj = target;
-  const keys = ["_count", "_sum", "_avg", "_min", "_max"];
-  for (const aggKey of keys) {
+  for (const aggKey of HAVING_FIELD_FIRST_AGG_KEYS) {
     const aggFilter = obj[aggKey];
     if (!isPlainObject(aggFilter)) continue;
-    if (Object.keys(aggFilter).length === 0) continue;
+    const aggFilterObj = aggFilter;
+    let hasAny = false;
+    for (const k in aggFilterObj) {
+      if (Object.prototype.hasOwnProperty.call(aggFilterObj, k)) {
+        hasAny = true;
+        break;
+      }
+    }
+    if (!hasAny) continue;
     if (aggKey === "_sum" || aggKey === "_avg") {
       assertNumericField(model, fieldName, "HAVING");
     }
     const expr = aggExprForField(aggKey, fieldName, alias, model);
-    out.push(...buildHavingOpsForExpr(expr, aggFilter, params, dialect));
+    out.push(...buildHavingOpsForExpr(expr, aggFilterObj, params, dialect));
   }
   return out;
 }
@@ -4157,13 +4348,13 @@ function normalizeCountArg(v) {
 }
 function pushCountAllField(fields) {
   fields.push(
-    `${SQL_TEMPLATES.COUNT_ALL} ${SQL_TEMPLATES.AS} ${quote("_count._all")}`
+    SQL_TEMPLATES.COUNT_ALL + " " + SQL_TEMPLATES.AS + " " + quote2("_count._all")
   );
 }
 function pushCountField(fields, alias, fieldName, model) {
-  const outAlias = `_count.${fieldName}`;
+  const outAlias = "_count." + fieldName;
   fields.push(
-    `COUNT(${col(alias, fieldName, model)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+    "COUNT(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote2(outAlias)
   );
 }
 function addCountFields(fields, countArg, alias, model) {
@@ -4176,12 +4367,14 @@ function addCountFields(fields, countArg, alias, model) {
   if (countArg._all === true) {
     pushCountAllField(fields);
   }
-  const selected = Object.entries(countArg).filter(
-    ([f, v]) => f !== "_all" && isTruthySelection(v)
-  );
-  for (const [f] of selected) {
-    assertScalarField(model, f, "_count");
-    pushCountField(fields, alias, f, model);
+  for (const f in countArg) {
+    if (!Object.prototype.hasOwnProperty.call(countArg, f)) continue;
+    if (f === "_all") continue;
+    const v = countArg[f];
+    if (isTruthySelection(v)) {
+      assertScalarField(model, f, "_count");
+      pushCountField(fields, alias, f, model);
+    }
   }
 }
 function getAggregateSelectionObject(args, agg) {
@@ -4196,16 +4389,18 @@ function assertAggregatableScalarField(model, agg, fieldName) {
   }
 }
 function pushAggregateFieldSql(fields, aggFn, alias, agg, fieldName, model) {
-  const outAlias = `${agg}.${fieldName}`;
+  const outAlias = agg + "." + fieldName;
   fields.push(
-    `${aggFn}(${col(alias, fieldName, model)}) ${SQL_TEMPLATES.AS} ${quote(outAlias)}`
+    aggFn + "(" + col(alias, fieldName, model) + ") " + SQL_TEMPLATES.AS + " " + quote2(outAlias)
   );
 }
 function addAggregateFields(fields, args, alias, model) {
   for (const [agg, aggFn] of AGGREGATES) {
     const obj = getAggregateSelectionObject(args, agg);
     if (!obj) continue;
-    for (const [fieldName, selection] of Object.entries(obj)) {
+    for (const fieldName in obj) {
+      if (!Object.prototype.hasOwnProperty.call(obj, fieldName)) continue;
+      const selection = obj[fieldName];
       if (fieldName === "_all")
         throw new Error(`'${agg}' does not support '_all'`);
       if (!isTruthySelection(selection)) continue;
@@ -4229,22 +4424,23 @@ function buildAggregateSql(args, whereResult, tableName, alias, model) {
     throw new Error("buildAggregateSql requires at least one aggregate field");
   }
   const selectClause = aggFields.join(SQL_SEPARATORS.FIELD_LIST);
-  const whereClause = isValidWhereClause(whereResult.clause) ? `${SQL_TEMPLATES.WHERE} ${whereResult.clause}` : "";
-  const sql = [
+  const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
+  const parts = [
     SQL_TEMPLATES.SELECT,
     selectClause,
     SQL_TEMPLATES.FROM,
     tableName,
-    alias,
-    whereClause
-  ].filter((x) => x && String(x).trim().length > 0).join(" ").trim();
+    alias
+  ];
+  if (whereClause) parts.push(whereClause);
+  const sql = parts.join(" ").trim();
   validateSelectQuery(sql);
   validateParamConsistency(sql, whereResult.params);
-  return Object.freeze({
+  return {
     sql,
-    params: Object.freeze([...whereResult.params]),
-    paramMappings: Object.freeze([...whereResult.paramMappings])
-  });
+    params: whereResult.params,
+    paramMappings: whereResult.paramMappings
+  };
 }
 function assertGroupByBy(args, model) {
   if (!isNotNullish(args.by) || !isNonEmptyArray(args.by)) {
@@ -4272,8 +4468,8 @@ function buildGroupByHaving(args, alias, params, model, dialect) {
   if (!isNotNullish(args.having)) return "";
   if (!isPlainObject(args.having)) throw new Error("having must be an object");
   const h = buildHavingClause(args.having, alias, params, model, dialect);
-  if (!h || h.trim().length === 0) return "";
-  return `${SQL_TEMPLATES.HAVING} ${h}`;
+  if (!h || h.length === 0) return "";
+  return SQL_TEMPLATES.HAVING + " " + h;
 }
 function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
   assertSafeAlias(alias);
@@ -4288,29 +4484,28 @@ function buildGroupBySql(args, whereResult, tableName, alias, model, dialect) {
     byFields
   );
   const havingClause = buildGroupByHaving(args, alias, params, model, d);
-  const whereClause = isValidWhereClause(whereResult.clause) ? `${SQL_TEMPLATES.WHERE} ${whereResult.clause}` : "";
-  const sql = [
+  const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
+  const parts = [
     SQL_TEMPLATES.SELECT,
     selectFields,
     SQL_TEMPLATES.FROM,
     tableName,
-    alias,
-    whereClause,
-    SQL_TEMPLATES.GROUP_BY,
-    groupFields,
-    havingClause
-  ].filter((x) => x && String(x).trim().length > 0).join(" ").trim();
+    alias
+  ];
+  if (whereClause) parts.push(whereClause);
+  parts.push(SQL_TEMPLATES.GROUP_BY, groupFields);
+  if (havingClause) parts.push(havingClause);
+  const sql = parts.join(" ").trim();
   const snapshot = params.snapshot();
+  const allParams = [...whereResult.params, ...snapshot.params];
+  const allMappings = [...whereResult.paramMappings, ...snapshot.mappings];
   validateSelectQuery(sql);
-  validateParamConsistency(sql, [...whereResult.params, ...snapshot.params]);
-  return Object.freeze({
+  validateParamConsistency(sql, allParams);
+  return {
     sql,
-    params: Object.freeze([...whereResult.params, ...snapshot.params]),
-    paramMappings: Object.freeze([
-      ...whereResult.paramMappings,
-      ...snapshot.mappings
-    ])
-  });
+    params: allParams,
+    paramMappings: allMappings
+  };
 }
 function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
   assertSafeAlias(alias);
@@ -4338,24 +4533,25 @@ function buildCountSql(whereResult, tableName, alias, skip, _dialect) {
       );
     }
   }
-  const whereClause = isValidWhereClause(whereResult.clause) ? `${SQL_TEMPLATES.WHERE} ${whereResult.clause}` : "";
-  const sql = [
+  const whereClause = isValidWhereClause(whereResult.clause) ? SQL_TEMPLATES.WHERE + " " + whereResult.clause : "";
+  const parts = [
     SQL_TEMPLATES.SELECT,
     SQL_TEMPLATES.COUNT_ALL,
     SQL_TEMPLATES.AS,
-    quote("_count._all"),
+    quote2("_count._all"),
     SQL_TEMPLATES.FROM,
     tableName,
-    alias,
-    whereClause
-  ].filter((x) => x && String(x).trim().length > 0).join(" ").trim();
+    alias
+  ];
+  if (whereClause) parts.push(whereClause);
+  const sql = parts.join(" ").trim();
   validateSelectQuery(sql);
   validateParamConsistency(sql, whereResult.params);
-  return Object.freeze({
+  return {
     sql,
-    params: Object.freeze([...whereResult.params]),
-    paramMappings: Object.freeze([...whereResult.paramMappings])
-  });
+    params: whereResult.params,
+    paramMappings: whereResult.paramMappings
+  };
 }
 function safeAlias(input) {
   const raw = String(input).toLowerCase();
@@ -4859,7 +5055,7 @@ function toSqliteParams(sql, params) {
   parts.push(sql.substring(lastIndex));
   return { sql: parts.join(""), params: reorderedParams };
 }
-function canonicalizeQuery(modelName, method, args) {
+function canonicalizeQuery(modelName, method, args, dialect) {
   function normalize(obj) {
     if (obj === null || obj === void 0) return obj;
     if (obj instanceof Date) {
@@ -4879,7 +5075,7 @@ function canonicalizeQuery(modelName, method, args) {
     return obj;
   }
   const canonical = normalize(args);
-  return `${modelName}:${method}:${JSON.stringify(canonical)}`;
+  return `${dialect}:${modelName}:${method}:${JSON.stringify(canonical)}`;
 }
 function buildSQLFull(model, models, method, args, dialect) {
   const tableName = buildTableReference(
@@ -4942,7 +5138,7 @@ function buildSQLFull(model, models, method, args, dialect) {
   return dialect === "sqlite" ? toSqliteParams(result.sql, result.params) : { sql: result.sql, params: [...result.params] };
 }
 function buildSQLWithCache(model, models, method, args, dialect) {
-  const cacheKey = canonicalizeQuery(model.name, method, args);
+  const cacheKey = canonicalizeQuery(model.name, method, args, dialect);
   const cachedSql = queryCache.get(cacheKey);
   if (cachedSql) {
     const result2 = buildSQLFull(model, models, method, args, dialect);
@@ -4950,6 +5146,7 @@ function buildSQLWithCache(model, models, method, args, dialect) {
   }
   const result = buildSQLFull(model, models, method, args, dialect);
   queryCache.set(cacheKey, result.sql);
+  queryCache.size;
   return result;
 }
 var ACCELERATED_METHODS = /* @__PURE__ */ new Set([