pqb 0.7.13 → 0.8.0

package/dist/index.esm.js

@@ -221,24 +221,24 @@ const windowToSql = (window, values, quotedAs) => {
   }
 };
 
-const processJoinItem = (ctx, model, args, quotedAs) => {
+const processJoinItem = (ctx, table, args, quotedAs) => {
   let target;
   let conditions;
   const [first] = args;
   if (typeof first === "string") {
-    if (first in model.relations) {
+    if (first in table.relations) {
       const {
         key,
         query: toQuery,
         joinQuery
-      } = model.relations[first];
-      const jq = joinQuery(model, toQuery);
+      } = table.relations[first];
+      const jq = joinQuery(table, toQuery);
       const { query } = jq;
-      const table = typeof query.from === "string" ? query.from : jq.table;
-      target = quoteSchemaAndTable(query.schema, table);
+      const tableName = typeof query.from === "string" ? query.from : jq.table;
+      target = quoteSchemaAndTable(query.schema, tableName);
       const as = query.as || key;
       const joinAs = q(as);
-      if (as !== table) {
+      if (as !== tableName) {
         target += ` AS ${joinAs}`;
       }
       const queryData = {
@@ -247,7 +247,7 @@ const processJoinItem = (ctx, model, args, quotedAs) => {
       };
       if (args[1]) {
         const arg = args[1](
-          new ctx.onQueryBuilder(jq, jq.shape, model)
+          new ctx.onQueryBuilder(jq, jq.shape, table)
         ).query;
         if (arg.and)
           queryData.and.push(...arg.and);
@@ -257,7 +257,7 @@ const processJoinItem = (ctx, model, args, quotedAs) => {
       conditions = whereToSql(ctx, jq, queryData, joinAs);
     } else {
       target = q(first);
-      conditions = processArgs(args, ctx, model, first, target, quotedAs);
+      conditions = processArgs(args, ctx, table, first, target, quotedAs);
     }
   } else {
     const query = first.query;
@@ -271,8 +271,8 @@ const processJoinItem = (ctx, model, args, quotedAs) => {
         target += ` AS ${quoted}`;
       }
     }
-    conditions = processArgs(args, ctx, model, first, joinAs, quotedAs);
-    const whereSql = whereToSql(ctx, model, query, joinAs);
+    conditions = processArgs(args, ctx, table, first, joinAs, quotedAs);
+    const whereSql = whereToSql(ctx, table, query, joinAs);
     if (whereSql) {
       if (conditions)
         conditions += ` AND ${whereSql}`;
@@ -282,21 +282,21 @@ const processJoinItem = (ctx, model, args, quotedAs) => {
   }
   return { target, conditions };
 };
-const processArgs = (args, ctx, model, first, joinAs, quotedAs) => {
+const processArgs = (args, ctx, table, first, joinAs, quotedAs) => {
   var _a;
   if (args.length === 2) {
     const arg = args[1];
     if (typeof arg === "function") {
       let shape;
       if (typeof first === "string") {
-        shape = (_a = model.query.withShapes) == null ? void 0 : _a[first];
+        shape = (_a = table.query.withShapes) == null ? void 0 : _a[first];
         if (!shape) {
           throw new Error("Cannot get shape of `with` statement");
         }
       } else {
         shape = first.shape;
       }
-      const jq = arg(new ctx.onQueryBuilder(first, shape, model));
+      const jq = arg(new ctx.onQueryBuilder(first, shape, table));
       return whereToSql(ctx, jq, jq.query, joinAs);
     } else {
       return getObjectOrRawConditions(arg, ctx.values, quotedAs, joinAs);
@@ -331,11 +331,11 @@ const getObjectOrRawConditions = (data, values, quotedAs, joinAs) => {
     return pairs.join(", ");
   }
 };
-const pushJoinSql = (ctx, model, query, quotedAs) => {
+const pushJoinSql = (ctx, table, query, quotedAs) => {
   query.join.forEach((item) => {
     const { target, conditions } = processJoinItem(
       ctx,
-      model,
+      table,
       item.args,
       quotedAs
     );
@@ -345,41 +345,41 @@ const pushJoinSql = (ctx, model, query, quotedAs) => {
   });
 };
 
-const pushWhereStatementSql = (ctx, model, query, quotedAs) => {
-  const res = whereToSql(ctx, model, query, quotedAs, false);
+const pushWhereStatementSql = (ctx, table, query, quotedAs) => {
+  const res = whereToSql(ctx, table, query, quotedAs, false);
   if (res) {
     ctx.sql.push("WHERE", res);
   }
 };
-const pushWhereToSql = (sql, ctx, model, query, quotedAs, not) => {
-  const res = whereToSql(ctx, model, query, quotedAs, not);
+const pushWhereToSql = (sql, ctx, table, query, quotedAs, not) => {
+  const res = whereToSql(ctx, table, query, quotedAs, not);
   if (res) {
     sql.push(res);
   }
 };
-const whereToSql = (ctx, model, query, quotedAs, not) => {
+const whereToSql = (ctx, table, query, quotedAs, not) => {
   if (query.or) {
     const ors = query.and ? [query.and, ...query.or] : query.or;
-    return ors.map((and) => processAnds(and, ctx, model, quotedAs, not)).join(" OR ");
+    return ors.map((and) => processAnds(and, ctx, table, quotedAs, not)).join(" OR ");
   } else if (query.and) {
-    return processAnds(query.and, ctx, model, quotedAs, not);
+    return processAnds(query.and, ctx, table, quotedAs, not);
   } else {
     return void 0;
   }
 };
-const processAnds = (and, ctx, model, quotedAs, not) => {
+const processAnds = (and, ctx, table, quotedAs, not) => {
   const ands = [];
-  and.forEach((data) => processWhere(ands, ctx, model, data, quotedAs, not));
+  and.forEach((data) => processWhere(ands, ctx, table, data, quotedAs, not));
   return ands.join(" AND ");
 };
-const processWhere = (ands, ctx, model, data, quotedAs, not) => {
+const processWhere = (ands, ctx, table, data, quotedAs, not) => {
   const prefix = not ? "NOT " : "";
   if (typeof data === "function") {
-    const qb = data(new ctx.whereQueryBuilder(model, model.shape));
+    const qb = data(new ctx.whereQueryBuilder(table, table.shape));
     pushWhereToSql(ands, ctx, qb, qb.query, quotedAs, not);
     return;
   }
-  if ("prototype" in data || "__model" in data) {
+  if ("prototype" in data || "__table" in data) {
     const query = data;
     const sql = whereToSql(
       ctx,
@@ -400,15 +400,15 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
     const value = data[key];
     if (key === "AND") {
       const arr = toArray(value);
-      ands.push(processAnds(arr, ctx, model, quotedAs, not));
+      ands.push(processAnds(arr, ctx, table, quotedAs, not));
     } else if (key === "OR") {
       const arr = value.map(toArray);
       ands.push(
-        arr.map((and) => processAnds(and, ctx, model, quotedAs, not)).join(" OR ")
+        arr.map((and) => processAnds(and, ctx, table, quotedAs, not)).join(" OR ")
       );
     } else if (key === "NOT") {
       const arr = toArray(value);
-      ands.push(processAnds(arr, ctx, model, quotedAs, !not));
+      ands.push(processAnds(arr, ctx, table, quotedAs, !not));
     } else if (key === "ON") {
       if (Array.isArray(value)) {
         const item = value;
@@ -417,7 +417,7 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
         const rightColumn = quoteFullColumn(
           item[2],
           getQueryAs({
-            table: model.table,
+            table: table.table,
             query: { as: quotedAs }
           })
         );
@@ -450,7 +450,7 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
       joinItems.forEach((item) => {
         const { target, conditions } = processJoinItem(
           ctx,
-          model,
+          table,
           item,
           quotedAs
         );
@@ -467,7 +467,7 @@ const processWhere = (ands, ctx, model, data, quotedAs, not) => {
           )}`
         );
       } else {
-        const column = model.shape[key];
+        const column = table.shape[key];
         if (!column) {
           throw new Error(`Unknown column ${key} provided to condition`);
         }
@@ -534,7 +534,7 @@ var __spreadValues$p = (a, b) => {
   return a;
 };
 var __spreadProps$j = (a, b) => __defProps$j(a, __getOwnPropDescs$j(b));
-const aggregateToSql = (ctx, model, item, quotedAs) => {
+const aggregateToSql = (ctx, table, item, quotedAs) => {
   var _a;
   const sql = [`${item.function}(`];
   ctx = __spreadProps$j(__spreadValues$p({}, ctx), { sql });
@@ -577,7 +577,7 @@ const aggregateToSql = (ctx, model, item, quotedAs) => {
   if (options.filter || options.filterOr) {
     const whereSql = whereToSql(
       ctx,
-      model,
+      table,
       {
         and: options.filter ? [options.filter] : void 0,
         or: (_a = options.filterOr) == null ? void 0 : _a.map((item2) => [item2])
@@ -673,10 +673,10 @@ const jsonToSql = (item, values, quotedAs) => {
   }
   return "";
 };
-const pushSelectSql = (ctx, model, query, quotedAs) => {
-  ctx.sql.push(selectToSql(ctx, model, query, quotedAs));
+const pushSelectSql = (ctx, table, query, quotedAs) => {
+  ctx.sql.push(selectToSql(ctx, table, query, quotedAs));
 };
-const selectToSql = (ctx, model, query, quotedAs) => {
+const selectToSql = (ctx, table, query, quotedAs) => {
   var _a;
   if (query.select) {
     const list = [];
@@ -713,13 +713,13 @@ const selectToSql = (ctx, model, query, quotedAs) => {
           list.push(
             `${item.function}(${selectToSql(
               ctx,
-              model,
+              table,
               { select: item.arguments },
               quotedAs
             )})${item.as ? ` AS ${q(item.as)}` : ""}`
           );
         } else {
-          list.push(aggregateToSql(ctx, model, item, quotedAs));
+          list.push(aggregateToSql(ctx, table, item, quotedAs));
         }
       }
     });
@@ -748,7 +748,7 @@ const pushSubQuerySql = (query, as, values, list) => {
       }
       select.length = 0;
       select[0] = { selectAs: { c: first } };
-      query = query._wrap(query.__model.clone());
+      query = query._wrap(query.__table.clone());
       query._getOptional(raw(`COALESCE(json_agg("c"), '[]')`));
       break;
     }
@@ -777,12 +777,12 @@ const aggregateOptionNames = [
   "filterOr",
   "withinGroup"
 ];
-const pushHavingSql = (ctx, model, query, quotedAs) => {
-  const conditions = havingToSql(ctx, model, query, quotedAs);
+const pushHavingSql = (ctx, table, query, quotedAs) => {
+  const conditions = havingToSql(ctx, table, query, quotedAs);
   if (conditions.length)
     ctx.sql.push("HAVING", conditions);
 };
-const havingToSql = (ctx, model, query, quotedAs) => {
+const havingToSql = (ctx, table, query, quotedAs) => {
   const or = query.having && query.havingOr ? [query.having, ...query.havingOr] : query.having ? [query.having] : query.havingOr;
   if (!(or == null ? void 0 : or.length))
     return "";
@@ -790,7 +790,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
   or.forEach((and) => {
     const ands = [];
     and.forEach((item) => {
-      if ("prototype" in item || "__model" in item) {
+      if ("prototype" in item || "__table" in item) {
         const query2 = item;
         const sql = havingToSql(
           ctx,
@@ -816,7 +816,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
                 if (!aggregateOptionNames.includes(
                   op
                 )) {
-                  const operator = model.shape[column].operators[op];
+                  const operator = table.shape[column].operators[op];
                   if (!operator) {
                     throw new Error(
                       `Unknown operator ${op} provided to condition`
@@ -824,7 +824,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
                   }
                   const expression = aggregateToSql(
                     ctx,
-                    model,
+                    table,
                     {
                       function: key,
                       arg: column,
@@ -845,7 +845,7 @@ const havingToSql = (ctx, model, query, quotedAs) => {
               ands.push(
                 `${aggregateToSql(
                   ctx,
-                  model,
+                  table,
                   {
                     function: key,
                     arg: column,
@@ -911,17 +911,17 @@ const queryKeysOfNotSimpleQuery = [
   "for"
 ];
 
-const pushFromAndAs = (ctx, model, query, quotedAs) => {
+const pushFromAndAs = (ctx, table, query, quotedAs) => {
   ctx.sql.push("FROM");
   if (query.fromOnly)
     ctx.sql.push("ONLY");
-  const from = getFrom(model, query, ctx.values);
+  const from = getFrom(table, query, ctx.values);
   ctx.sql.push(from);
   if (query.as && quotedAs && quotedAs !== from) {
     ctx.sql.push("AS", quotedAs);
   }
 };
-const getFrom = (model, query, values) => {
+const getFrom = (table, query, values) => {
   if (query.from) {
     if (typeof query.from === "object") {
       if (isRaw(query.from)) {
@@ -940,7 +940,7 @@ const getFrom = (model, query, values) => {
     }
     return quoteSchemaAndTable(query.schema, query.from);
   }
-  return quoteSchemaAndTable(query.schema, model.table);
+  return quoteSchemaAndTable(query.schema, table.table);
 };
 
 const pushQueryArray = (q, key, value) => {
@@ -970,7 +970,7 @@ const setQueryObjectValue = (q, object, key, value) => {
   return q;
 };
 
-const pushInsertSql = (ctx, model, query, quotedAs) => {
+const pushInsertSql = (ctx, table, query, quotedAs) => {
   const quotedColumns = query.columns.map(q);
   ctx.sql.push(`INSERT INTO ${quotedAs}(${quotedColumns.join(", ")})`);
   if (query.fromQuery) {
@@ -1025,22 +1025,22 @@ const pushInsertSql = (ctx, model, query, quotedAs) => {
       ctx.sql.push("DO UPDATE SET", set);
     }
   }
-  pushWhereStatementSql(ctx, model, query, quotedAs);
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };
 const encodeRow = (ctx, row) => {
   return row.map(
     (value) => value === void 0 ? "DEFAULT" : addValue(ctx.values, value)
   ).join(", ");
 };
-const pushReturningSql = (ctx, model, query, quotedAs) => {
+const pushReturningSql = (ctx, table, query, quotedAs) => {
   if (query.select) {
-    ctx.sql.push(`RETURNING ${selectToSql(ctx, model, query, quotedAs)}`);
+    ctx.sql.push(`RETURNING ${selectToSql(ctx, table, query, quotedAs)}`);
   }
 };
 
-const pushUpdateSql = (ctx, model, query, quotedAs) => {
-  const quotedTable = quoteSchemaAndTable(query.schema, model.table);
+const pushUpdateSql = (ctx, table, query, quotedAs) => {
+  const quotedTable = quoteSchemaAndTable(query.schema, table.table);
   ctx.sql.push(`UPDATE ${quotedTable}`);
   if (quotedTable !== quotedAs) {
     ctx.sql.push(`AS ${quotedAs}`);
@@ -1049,8 +1049,8 @@ const pushUpdateSql = (ctx, model, query, quotedAs) => {
   const set = [];
   processData(ctx, set, query.updateData);
   ctx.sql.push(set.join(", "));
-  pushWhereStatementSql(ctx, model, query, quotedAs);
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };
 const processData = (ctx, set, data) => {
   let append;
@@ -1087,9 +1087,9 @@ const processValue = (values, key, value) => {
   return addValue(values, value);
 };
 
-const pushDeleteSql = (ctx, model, query, quotedAs) => {
+const pushDeleteSql = (ctx, table, query, quotedAs) => {
   var _a, _b, _c;
-  const from = q(model.table);
+  const from = q(table.table);
   ctx.sql.push(`DELETE FROM ${from}`);
   if (from !== quotedAs) {
     ctx.sql.push(`AS ${quotedAs}`);
@@ -1097,12 +1097,12 @@ const pushDeleteSql = (ctx, model, query, quotedAs) => {
   let conditions;
   if ((_a = query.join) == null ? void 0 : _a.length) {
     const items = query.join.map(
-      (item) => processJoinItem(ctx, model, item.args, quotedAs)
+      (item) => processJoinItem(ctx, table, item.args, quotedAs)
     );
     ctx.sql.push(`USING ${items.map((item) => item.target).join(", ")}`);
     conditions = items.map((item) => item.conditions).filter(Boolean).join(" AND ");
   }
-  pushWhereStatementSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
   if (conditions == null ? void 0 : conditions.length) {
     if (((_b = query.and) == null ? void 0 : _b.length) || ((_c = query.or) == null ? void 0 : _c.length)) {
       ctx.sql.push("AND", conditions);
@@ -1110,7 +1110,7 @@ const pushDeleteSql = (ctx, model, query, quotedAs) => {
       ctx.sql.push("WHERE", conditions);
     }
   }
-  pushReturningSql(ctx, model, query, quotedAs);
+  pushReturningSql(ctx, table, query, quotedAs);
 };
 
 const pushTruncateSql = (ctx, table, query) => {
@@ -1133,13 +1133,13 @@ const pushColumnInfoSql = (ctx, table, query) => {
   }
 };
 
-const pushCopySql = (ctx, model, query, quotedAs) => {
+const pushCopySql = (ctx, table, query, quotedAs) => {
   const { sql } = ctx;
   const { copy } = query;
   const columns = copy.columns ? `(${copy.columns.map(q).join(", ")})` : "";
   const target = "from" in copy ? copy.from : copy.to;
   sql.push(
-    `COPY ${q(model.table)}${columns} ${"from" in copy ? "FROM" : "TO"} ${typeof target === "string" ? quote(target) : `PROGRAM ${quote(target.program)}`}`
+    `COPY ${q(table.table)}${columns} ${"from" in copy ? "FROM" : "TO"} ${typeof target === "string" ? quote(target) : `PROGRAM ${quote(target.program)}`}`
   );
   if (Object.keys(copy).length > (copy.columns ? 2 : 1)) {
     const options = [];
@@ -1169,19 +1169,19 @@ const pushCopySql = (ctx, model, query, quotedAs) => {
       options.push(`ENCODING ${quote(copy.encoding)}`);
     sql.push(`WITH (${options.join(", ")})`);
   }
-  pushWhereStatementSql(ctx, model, query, quotedAs);
+  pushWhereStatementSql(ctx, table, query, quotedAs);
 };
 
 const toSqlCacheKey = Symbol("toSqlCache");
-const toSql = (model, options) => {
-  return !(options == null ? void 0 : options.clearCache) && model.query[toSqlCacheKey] || (model.query[toSqlCacheKey] = makeSql(model, options));
+const toSql = (table, options) => {
+  return !(options == null ? void 0 : options.clearCache) && table.query[toSqlCacheKey] || (table.query[toSqlCacheKey] = makeSql(table, options));
 };
-const makeSql = (model, { values = [] } = {}) => {
-  const query = model.query;
+const makeSql = (table, { values = [] } = {}) => {
+  const query = table.query;
   const sql = [];
   const ctx = {
-    whereQueryBuilder: model.whereQueryBuilder,
-    onQueryBuilder: model.onQueryBuilder,
+    whereQueryBuilder: table.whereQueryBuilder,
+    onQueryBuilder: table.onQueryBuilder,
     sql,
     values
   };
@@ -1190,56 +1190,56 @@ const makeSql = (model, { values = [] } = {}) => {
   }
   if (query.type) {
     if (query.type === "truncate") {
-      if (!model.table)
+      if (!table.table)
         throw new Error("Table is missing for truncate");
-      pushTruncateSql(ctx, model.table, query);
+      pushTruncateSql(ctx, table.table, query);
       return { text: sql.join(" "), values };
     }
     if (query.type === "columnInfo") {
-      if (!model.table)
+      if (!table.table)
         throw new Error("Table is missing for truncate");
-      pushColumnInfoSql(ctx, model.table, query);
+      pushColumnInfoSql(ctx, table.table, query);
       return { text: sql.join(" "), values };
     }
-    if (!model.table)
+    if (!table.table)
       throw new Error(`Table is missing for ${query.type}`);
-    const quotedAs2 = q(query.as || model.table);
+    const quotedAs2 = q(query.as || table.table);
     if (query.type === "insert") {
-      pushInsertSql(ctx, model, query, q(model.table));
+      pushInsertSql(ctx, table, query, q(table.table));
       return { text: sql.join(" "), values };
     }
     if (query.type === "update") {
-      pushUpdateSql(ctx, model, query, quotedAs2);
+      pushUpdateSql(ctx, table, query, quotedAs2);
       return { text: sql.join(" "), values };
     }
     if (query.type === "delete") {
-      pushDeleteSql(ctx, model, query, quotedAs2);
+      pushDeleteSql(ctx, table, query, quotedAs2);
       return { text: sql.join(" "), values };
     }
     if (query.type === "copy") {
-      pushCopySql(ctx, model, query, quotedAs2);
+      pushCopySql(ctx, table, query, quotedAs2);
       return { text: sql.join(" "), values };
     }
   }
-  const quotedAs = model.table && q(query.as || model.table);
+  const quotedAs = table.table && q(query.as || table.table);
   sql.push("SELECT");
   if (query.distinct) {
     pushDistinctSql(ctx, query.distinct, quotedAs);
   }
-  pushSelectSql(ctx, model, query, quotedAs);
-  if (model.table || query.from) {
-    pushFromAndAs(ctx, model, query, quotedAs);
+  pushSelectSql(ctx, table, query, quotedAs);
+  if (table.table || query.from) {
+    pushFromAndAs(ctx, table, query, quotedAs);
   }
   if (query.join) {
     pushJoinSql(
       ctx,
-      model,
+      table,
       query,
       quotedAs
     );
   }
   if (query.and || query.or) {
-    pushWhereStatementSql(ctx, model, query, quotedAs);
+    pushWhereStatementSql(ctx, table, query, quotedAs);
   }
   if (query.group) {
     const group = query.group.map(
@@ -1248,7 +1248,7 @@ const makeSql = (model, { values = [] } = {}) => {
     sql.push(`GROUP BY ${group.join(", ")}`);
   }
   if (query.having || query.havingOr) {
-    pushHavingSql(ctx, model, query, quotedAs);
+    pushHavingSql(ctx, table, query, quotedAs);
   }
   if (query.window) {
     const window = [];
@@ -4154,9 +4154,9 @@ class Delete {
 
 const forQueryBuilder = (q, type, tableNames) => {
   q.query.for = { type, tableNames };
-  q.__model = Object.create(q.__model);
-  q.__model.__model = q.__model;
-  Object.assign(q.__model, {
+  q.__table = Object.create(q.__table);
+  q.__table.__table = q.__table;
+  Object.assign(q.__table, {
     noWait() {
       return this.clone()._noWait();
     },
@@ -4247,7 +4247,7 @@ var __spreadValues$5 = (a, b) => {
   return a;
 };
 const processHavingArg = (arg) => {
-  if ("__model" in arg || isRaw(arg)) {
+  if ("__table" in arg || isRaw(arg)) {
     return arg;
   } else {
     const processed = __spreadValues$5({}, arg);
@@ -4694,13 +4694,13 @@ class WhereQueryBuilder extends Where {
     this.withData = {};
     this.table = typeof q === "object" ? q.table : q;
     this.shape = shape;
-    this.__model = this;
+    this.__table = this;
     if (typeof q === "object" && q.query.as) {
       this.query.as = q.query.as;
     }
   }
   clone() {
-    const cloned = Object.create(this.__model);
+    const cloned = Object.create(this.__table);
     cloned.query = getClonedQueryData(this.query);
     return cloned;
   }
@@ -4841,7 +4841,7 @@ class Json {
     return this.clone()._json();
   }
   _json() {
-    const q = this._wrap(this.__model.clone());
+    const q = this._wrap(this.__table.clone());
     q._getOptional(
       raw(
         queryTypeWithLimitOne[this.query.returnType] ? `row_to_json("t".*)` : `COALESCE(json_agg(row_to_json("t".*)), '[]')`
@@ -5247,7 +5247,7 @@ class Update {
         ctx.resultAll = await handleResult(q, queryResult);
         if (ctx.updateLater) {
           await Promise.all(ctx.updateLaterPromises);
-          const t = this.__model.clone().transacting(q);
+          const t = this.__table.clone().transacting(q);
           const keys = this.primaryKeys;
           t._whereIn(
             keys,
@@ -5496,7 +5496,7 @@ class QueryMethods {
     return this;
   }
   clone() {
-    const cloned = Object.create(this.__model);
+    const cloned = Object.create(this.__table);
     cloned.query = getClonedQueryData(this.query);
     return cloned;
   }
@@ -5680,7 +5680,7 @@ class Db {
     this.whereQueryBuilder = WhereQueryBuilder;
     this.onQueryBuilder = OnQueryBuilder;
     var _a, _b;
-    this.__model = this;
+    this.__table = this;
     const logger = options.logger || console;
     this.query = {
       adapter,