pqb 0.61.13 → 0.62.1

package/dist/index.js

@@ -2,10 +2,10 @@
 
 var url = require('url');
 var path = require('node:path');
-var promises = require('timers/promises');
-var pqb = require('pqb');
+var internal = require('pqb/internal');
 var node_util = require('node:util');
 var node_async_hooks = require('node:async_hooks');
+var promises = require('timers/promises');
 
 function applyMixins(targetClass, mixinClasses) {
   const target = targetClass.prototype;
@@ -157,7 +157,7 @@ const getCallerFilePath = (stack = getStackTrace()) => {
       } else {
         try {
           file = new URL(file).pathname;
-        } catch (_) {
+        } catch {
         }
       }
       return file;
@@ -232,32 +232,7 @@ const colors = {
   pale: (s) => `\x1B[2m${s}\x1B[0m`
 };
 
-const setConnectRetryConfig = (adapter, config) => {
-  adapter.connectRetryConfig = {
-    attempts: config.attempts ?? 10,
-    strategy: typeof config.strategy === "function" ? config.strategy : defaultConnectRetryStrategy(config.strategy ?? emptyObject)
-  };
-};
-const wrapAdapterFnWithConnectRetry = (adapter, fn) => {
-  return async function(...args) {
-    let attempt = 1;
-    for (; ; ) {
-      try {
-        return await fn.call(this, ...args);
-      } catch (err) {
-        const config = adapter.connectRetryConfig;
-        if (!err || typeof err !== "object" || err.code !== "ECONNREFUSED" || !config || attempt >= config.attempts) {
-          throw err;
-        }
-        await config.strategy(attempt, config.attempts);
-        attempt++;
-      }
-    }
-  };
-};
-const defaultConnectRetryStrategy = (param) => {
-  return (attempt) => promises.setTimeout((param.factor ?? 1.5) ** (attempt - 1) * (param.delay ?? 50));
-};
+const snakeCaseKey = Symbol("snakeCase");
 
 class Expression {
   // Produce SQL string by calling `makeSQL` and applying operators from the `q.chain`, push query variables into given `values` array.
@@ -470,6 +445,108 @@ class UnsafeSqlExpression extends Expression {
   }
 }
 
+const makeIndex = (columns, first, second) => {
+  if (typeof first === "string") {
+    const options = { ...second, name: first };
+    return {
+      index: { columns, options }
+    };
+  } else {
+    const options = first ?? {};
+    return {
+      index: { columns, options }
+    };
+  }
+};
+const tableDataMethods = {
+  primaryKey(columns, name) {
+    return { primaryKey: { columns, name } };
+  },
+  unique(columns, ...args) {
+    const [first, second] = args;
+    const input = makeIndex(columns, first, second);
+    input.index.options.unique = true;
+    return input;
+  },
+  index: makeIndex,
+  searchIndex(columns, ...args) {
+    var _a;
+    const [first, second] = args;
+    const input = makeIndex(columns, first, second);
+    (_a = input.index.options).using ?? (_a.using = "gin");
+    input.index.options.tsVector = true;
+    return input;
+  },
+  exclude(columns, ...args) {
+    const [first, second] = args;
+    if (typeof first === "string") {
+      const options = second ?? {};
+      return {
+        exclude: { columns, options: { ...options, name: first } }
+      };
+    } else {
+      const options = first ?? {};
+      return {
+        exclude: { columns, options }
+      };
+    }
+  },
+  foreignKey(columns, fnOrTable, foreignColumns, options) {
+    return {
+      constraint: {
+        name: options?.name,
+        references: { columns, fnOrTable, foreignColumns, options }
+      }
+    };
+  },
+  check(check, name) {
+    return { constraint: { check, name } };
+  },
+  sql: sqlFn
+};
+const parseTableData = (dataFn) => {
+  const tableData = {};
+  if (dataFn) {
+    const input = dataFn(tableDataMethods);
+    if (Array.isArray(input)) {
+      for (const item of input) {
+        parseTableDataInput(tableData, item);
+      }
+    } else {
+      parseTableDataInput(tableData, input);
+    }
+  }
+  return tableData;
+};
+const parseTableDataInput = (tableData, item) => {
+  if (item.primaryKey) {
+    tableData.primaryKey = item.primaryKey;
+  } else if (item.index) {
+    (tableData.indexes ?? (tableData.indexes = [])).push(
+      parseIndexOrExclude(item.index)
+    );
+  } else if (item.exclude) {
+    (tableData.excludes ?? (tableData.excludes = [])).push(
+      parseIndexOrExclude(item.exclude)
+    );
+  } else if (item.constraint) {
+    (tableData.constraints ?? (tableData.constraints = [])).push(item.constraint);
+    if (item.constraint.references?.options?.dropMode) {
+      item.constraint.dropMode = item.constraint.references.options.dropMode;
+    }
+  }
+};
+const parseIndexOrExclude = (item) => {
+  for (let i = item.columns.length - 1; i >= 0; i--) {
+    if (typeof item.columns[i] === "string") {
+      item.columns[i] = {
+        column: item.columns[i]
+      };
+    }
+  }
+  return item;
+};
+
 function makeColumnNullable(column, inputSchema, outputSchema, querySchema) {
   const c = setColumnData(column, "isNullable", true);
   c.inputSchema = inputSchema;
@@ -514,9 +591,6 @@ const setDefaultNowFn = (sql) => {
   currentNowFn = sql;
 };
 const getDefaultNowFn = () => currentNowFn;
-const resetDefaultNowFn = () => {
-  currentNowFn = defaultNowFn;
-};
 let defaultLanguage = "english";
 const setDefaultLanguage = (lang) => {
   defaultLanguage = lang || "english";
@@ -1465,7 +1539,6 @@ const excludeInnerToCode = (item, t) => {
 const excludeToCode = indexOrExcludeToCode(excludeInnerToCode);
 const constraintToCode = (item, t, m, prefix) => {
   const code = constraintInnerToCode(item, t, m);
-  if (prefix) code[0] = prefix + code[0];
   const last = code[code.length - 1];
   if (typeof last === "string" && !last.endsWith(","))
     code[code.length - 1] += ",";
@@ -1847,7 +1920,7 @@ const make = (_op) => {
       // function to turn the operator expression into SQL
       _op
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    //
   );
 };
 const makeVarArg = (_op) => {
@@ -1869,7 +1942,7 @@ const makeVarArg = (_op) => {
       // function to turn the operator expression into SQL
       _op
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    //
   );
 };
 const prepareOpArg = (q, arg) => {
@@ -3191,10 +3264,6 @@ const typmodType = (typmod) => {
 const typmodSrid = (typmod) => {
   return typmod < 0 ? 0 : (typmod & 268435200) - (typmod & 268435456) >> 8;
 };
-const postgisTypmodToSql = (typmod) => {
-  const srid = typmodSrid(typmod);
-  return typmodType(typmod) + (srid === defaultSrid ? "" : ", " + srid);
-};
 let byteToHex;
 function uint8ArrToHex(arr) {
   if (!byteToHex) {
@@ -3420,8 +3489,6 @@ const anyShape = new Proxy(emptyObject, {
   }
 });
 
-const snakeCaseKey = Symbol("snakeCase");
-
 const pushQueryValueImmutable = (q, key, value) => {
   pushOrNewArrayToObjectImmutable(
     q.q,
@@ -3448,447 +3515,354 @@ class QueryClone {
   }
 }
 
-const getQueryAs = (q) => {
-  return q.q.as || q.table;
-};
-const requireQueryAs = (q) => {
-  const as = getQueryAs(q);
-  if (!as) throw new Error(`Table name or alias is missing`);
-  return as;
+const before = (q, key, cb) => pushQueryValueImmutable(q, `before${key}`, cb);
+const after = (query, key, select, cb, commit) => {
+  const q = query;
+  pushQueryValueImmutable(
+    q,
+    `after${key}${commit ? "Commit" : ""}`,
+    cb
+  );
+  if (key === "Save") {
+    addSelect(q, "Create", select);
+    addSelect(q, "Update", select);
+  } else {
+    addSelect(q, key, select);
+  }
+  return query;
 };
-const _getQueryAs = (q) => q.q.as;
-const _getQueryFreeAlias = (q, as) => q.aliases ? getFreeAlias(q.aliases, as) : as;
-const _checkIfAliased = (q, as, name) => {
-  return q.q.aliases?.[as] === name;
+const addSelect = (q, key, select) => {
+  const prop = `after${key}Select`;
+  const set = q.q[prop] = new Set(q.q[prop]);
+  for (const column of select) {
+    set.add(column);
+  }
 };
-const _getQueryAliasOrName = (q, as) => {
-  return q.aliases?.[as] || as;
+const _queryHookBeforeQuery = (q, cb) => {
+  return pushQueryValueImmutable(q, "before", cb);
 };
-const _getQueryOuterAliases = (q) => {
-  return q.outerAliases;
+const _queryHookAfterQuery = (q, cb) => {
+  return pushQueryValueImmutable(q, "after", cb);
 };
-const _setQueryAs = (self, as) => {
-  const { q } = self;
-  q.as = as;
-  q.aliases = {
-    ...q.aliases,
-    [as]: _getQueryFreeAlias(q, as)
+const _hookSelectColumns = (query, columns, asFn) => {
+  const hookSelect = query.q.hookSelect = new Map(
+    query.q.hookSelect && [...query.q.hookSelect]
+  );
+  const aliases = [];
+  const addAlias = (as) => {
+    aliases.push(as);
+    if (aliases.length === columns.length) {
+      asFn(aliases);
+    }
   };
-  return self;
-};
-const _setQueryAlias = (q, name, as) => {
-  q.q.aliases = { ...q.q.aliases, [as]: name };
-};
-const _setSubQueryAliases = (q) => {
-  q.q.outerAliases = q.q.aliases;
-};
-const _applyRelationAliases = (query, relQueryData) => {
-  const aliases = query.q.as ? { ...query.q.aliases } : { ...query.q.aliases, [query.table]: query.table };
-  const relAliases = relQueryData.aliases;
-  for (const as in relAliases) {
-    aliases[as] = getFreeAlias(aliases, as);
-  }
-  relQueryData.as = aliases[relQueryData.as];
-  relQueryData.aliases = aliases;
-};
-const _copyQueryAliasToQuery = (fromQuery, toQuery, key) => {
-  const name = _getQueryAliasOrName(fromQuery.q, key);
-  if (name !== key) {
-    _setQueryAlias(toQuery, name, key);
+  for (const column of columns) {
+    const item = hookSelect.get(column);
+    hookSelect.set(column, {
+      ...item,
+      select: column,
+      onAs: [...item?.onAs || emptyArray, addAlias]
+    });
   }
-  return name;
 };
-class QueryAsMethods {
-  /**
-   * Sets table alias:
-   *
-   * ```ts
-   * db.table.as('u').select('u.name');
-   *
-   * // Can be used in the join:
-   * db.table.join(db.profile.as('p'), 'p.userId', 'user.id');
-   * ```
-   *
-   * @param as - alias for the table of this query
-   */
-  as(as) {
-    return _setQueryAs(_clone(this), as);
+class QueryHookUtils {
+  constructor(query, columns, key) {
+    this.query = query;
+    this.columns = columns;
+    this.key = key;
+    this.set = (data) => {
+      const set = {};
+      for (const key in data) {
+        if (data[key] !== void 0) {
+          set[key] = data[key];
+        }
+      }
+      pushQueryValueImmutable(this.query, this.key, set);
+    };
   }
 }
-
-const queryColumnNameToKey = (q, name) => {
-  let map = q.internal.columnNameToKeyMap;
-  if (!map) {
-    q.internal.columnNameToKeyMap = map = /* @__PURE__ */ new Map();
-    const { shape } = q;
-    for (const key in q.shape) {
-      const column = shape[key];
-      map.set(column.data.name ?? key, key);
+const finalizeNestedHookSelect = (batches, returnType, tempColumns, renames, key) => {
+  if (renames) {
+    for (const { data } of batches) {
+      for (const record of data) {
+        if (record) {
+          for (const a in renames) {
+            record[a] = record[renames[a]];
+          }
+        }
+      }
     }
   }
-  return map.get(name);
-};
-
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
-var _query, _query2, _columnsCache;
-class OrchidOrmError extends Error {
-}
-class NotFoundError extends OrchidOrmError {
-  constructor(query, message = "Record is not found") {
-    super(message);
-    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
-    // it is exposed with `getQuery` method which prevents this problem from both Vitest and Jest.
-    // Exposing it with `get query()` still leaves the issue in Vitest.
-    __privateAdd(this, _query);
-    __privateSet(this, _query, query);
-  }
-  getQuery() {
-    return __privateGet(this, _query);
-  }
-}
-_query = new WeakMap();
-class OrchidOrmInternalError extends Error {
-  constructor(query, message, data) {
-    super(message);
-    this.data = data;
-    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
-    // it is exposed with `getQuery` method which prevents this problem from both Vitest and Jest.
-    // Exposing it with `get query()` still leaves the issue in Vitest.
-    __privateAdd(this, _query2);
-    __privateSet(this, _query2, query);
-  }
-  getQuery() {
-    return __privateGet(this, _query2);
-  }
-}
-_query2 = new WeakMap();
-class QueryError extends OrchidOrmInternalError {
-  constructor() {
-    super(...arguments);
-    __privateAdd(this, _columnsCache);
-  }
-  get isUnique() {
-    return this.code === "23505";
-  }
-  get columns() {
-    if (__privateGet(this, _columnsCache)) return __privateGet(this, _columnsCache);
-    const columns = {};
-    if (this.detail) {
-      const list = this.detail.match(/\((.*)\)=/)?.[1];
-      if (list) {
-        list.split(", ").forEach((item) => {
-          const column = item.startsWith('"') ? item.slice(1, -1) : item;
-          const key = queryColumnNameToKey(this.getQuery(), column) ?? column;
-          columns[key] = true;
-        });
+  if (tempColumns?.size) {
+    for (const { data } of batches) {
+      for (const record of data) {
+        if (record) {
+          for (const key2 of tempColumns) {
+            delete record[key2];
+          }
+        }
       }
     }
-    return __privateSet(this, _columnsCache, columns);
-  }
-}
-_columnsCache = new WeakMap();
-class MoreThanOneRowError extends OrchidOrmInternalError {
-  constructor(query, message) {
-    super(query, message);
   }
-}
-class UnhandledTypeError extends OrchidOrmInternalError {
-  constructor(query, value) {
-    super(query, `Unhandled type: ${JSON.stringify(value)} received`);
+  if (returnType === "one" || returnType === "oneOrThrow") {
+    for (const batch of batches) {
+      batch.data = batch.data[0];
+    }
+  } else if (returnType === "pluck") {
+    for (const { data } of batches) {
+      for (let i = 0; i < data.length; i++) {
+        data[i] = data[i][key];
+      }
+    }
+  } else if (returnType === "value" || returnType === "valueOrThrow") {
+    for (const item of batches) {
+      item.parent[item.key] = item.data[0]?.[key];
+    }
   }
-}
-
-const pushQueryArrayImmutable = (q, key, value) => {
-  const arr = q.q[key];
-  q.q[key] = arr ? [...arr, ...value] : value;
-  return q;
 };
-const setQueryObjectValueImmutable = (q, object, key, value) => {
-  q.q[object] = {
-    ...q.q[object],
-    [key]: value
-  };
-  return q;
+const _queryHookBeforeCreate = (q, cb) => {
+  return before(
+    q,
+    "Create",
+    (q2) => cb(new QueryHookUtils(q2, q2.q.columns, "hookCreateSet"))
+  );
 };
-const throwIfNoWhere = (q, method) => {
-  if (!q.q.or && !q.q.and && !q.q.scopes && !q.q.all) {
-    throw new OrchidOrmInternalError(
-      q,
-      `Dangerous ${method} without conditions`
-    );
-  }
+const _queryHookAfterCreate = (q, select, cb) => {
+  return after(q, "Create", select, cb);
 };
-const throwIfJoinLateral = (q, method) => {
-  if (q.q.join?.some((x) => Array.isArray(x) || "s" in x.args && x.args.s)) {
-    throw new OrchidOrmInternalError(
-      q,
-      `Cannot join a complex query in ${method}`
-    );
-  }
+const _queryHookAfterCreateCommit = (q, select, cb) => {
+  return after(q, "Create", select, cb, true);
 };
-const throwOnReadOnlyUpdate = (query, column, key) => {
-  if (column.data.appReadOnly || column.data.readOnly) {
-    throw new OrchidOrmInternalError(
-      query,
-      "Trying to update a readonly column",
-      { column: key }
-    );
-  }
+const _queryHookBeforeUpdate = (q, cb) => {
+  return before(q, "Update", (q2) => {
+    const columns = /* @__PURE__ */ new Set();
+    if (q2.q.updateData) {
+      for (const item of q2.q.updateData) {
+        if (typeof item === "object") {
+          for (const key in item) {
+            columns.add(key);
+          }
+        }
+      }
+    }
+    if (q2.q.updateMany) {
+      for (const key of q2.q.updateMany.setColumns) {
+        columns.add(key);
+      }
+    }
+    return cb(new QueryHookUtils(q2, [...columns], "hookUpdateSet"));
+  });
 };
-const saveAliasedShape = (q, as, key) => {
-  const shapes = q.q[key];
-  as = getFreeAlias(shapes, as);
-  setQueryObjectValueImmutable(q, key, as, emptyObject);
-  return as;
+const _queryHookAfterUpdate = (q, select, cb) => {
+  return after(q, "Update", select, cb);
 };
-const extendQuery = (q, methods) => {
-  const base = Object.create(q.baseQuery);
-  base.baseQuery = base;
-  Object.assign(base, methods);
-  const cloned = Object.create(base);
-  cloned.q = getClonedQueryData(q.q);
-  return cloned;
+const _queryHookAfterUpdateCommit = (q, select, cb) => {
+  return after(q, "Update", select, cb, true);
 };
-const _queryAll = (q) => {
-  q.q.returnType = "all";
-  q.q.all = true;
-  return q;
+const _queryHookBeforeSave = (q, cb) => {
+  return _queryHookBeforeUpdate(_queryHookBeforeCreate(q, cb), cb);
 };
-const _queryTake = (query) => {
-  const q = query.q;
-  switch (q.returnType) {
-    case "valueOrThrow":
-    case "pluck":
-    case "void":
-      break;
-    case "value": {
-      q.returnType = "valueOrThrow";
-      break;
-    }
-    default: {
-      q.returnType = "oneOrThrow";
-    }
-  }
-  return query;
+const _queryHookAfterSave = (q, select, cb) => {
+  return after(q, "Save", select, cb);
 };
-const _queryTakeOptional = (query) => {
-  const q = query.q;
-  switch (q.returnType) {
-    case "value":
-    case "pluck":
-    case "void":
-      break;
-    case "valueOrThrow": {
-      q.returnType = "value";
-      break;
-    }
-    default: {
-      q.returnType = "one";
-    }
-  }
-  return query;
+const _queryAfterSaveCommit = (q, select, cb) => {
+  return after(q, "Save", select, cb, true);
 };
-const _queryExec = (q) => {
-  q.q.returnType = "void";
-  return q;
+const _queryHookBeforeDelete = (q, cb) => {
+  return before(q, "Delete", cb);
 };
-const _queryRows = (q) => {
-  q.q.returnType = "rows";
-  return q;
+const _queryHookAfterDelete = (q, select, cb) => {
+  return after(q, "Delete", select, cb);
 };
-const getFullColumnTable = (q, column, index, as) => {
-  const table = column.slice(0, index);
-  return as && table !== as && _checkIfAliased(q, table, as) ? as : table;
+const _queryHookAfterDeleteCommit = (q, select, cb) => {
+  return after(q, "Delete", select, cb, true);
 };
-
-const prepareSubQueryForSql = (mainQuery, subQuery) => {
-  if (subQuery.dynamicBefore) {
-    pushQueryValueImmutable(mainQuery, "dynamicBefore", subQuery.q);
-    return subQuery;
+class QueryHooks {
+  /**
+   * Run the function before any kind of query.
+   *
+   * @param cb - function to call, first argument is a query object
+   */
+  beforeQuery(cb) {
+    return _queryHookBeforeQuery(_clone(this), cb);
   }
-  let beforeAction = subQuery.q.type ? subQuery.q.type === "insert" ? subQuery.q.beforeCreate : subQuery.q.type === "update" ? subQuery.q.beforeUpdate : subQuery.q.type === "upsert" ? subQuery.q.upsertUpdate && subQuery.q.updateData ? subQuery.q.beforeUpdate && subQuery.q.beforeCreate ? [...subQuery.q.beforeUpdate, ...subQuery.q.beforeCreate] : subQuery.q.beforeUpdate || subQuery.q.beforeCreate : subQuery.q.beforeCreate : subQuery.q.type === "delete" ? subQuery.q.beforeDelete : void 0 : void 0;
-  const { beforeSet } = subQuery.q;
-  beforeAction = beforeAction && beforeSet ? [...beforeAction, ...beforeSet] : beforeSet ? [...beforeSet] : beforeAction;
-  if (beforeAction) {
-    const newSet = new Set(mainQuery.q.beforeSet);
-    const filteredHooks = [];
-    for (const hook of beforeAction) {
-      if (!newSet.has(hook)) {
-        newSet.add(hook);
-        filteredHooks.push(hook);
-      }
-    }
-    mainQuery.q.beforeSet = newSet;
-    beforeAction = filteredHooks;
-    if (beforeAction.length) {
-      pushQueryArrayImmutable(
-        mainQuery,
-        "before",
-        beforeAction.map((fn) => () => fn(subQuery))
-      );
-    }
-  }
-  return subQuery;
-};
-setPrepareSubQueryForSql(prepareSubQueryForSql);
-setRawSqlPrepareSubQueryForSql(prepareSubQueryForSql);
-
-const _queryUnion = (base, args, k, p, m) => {
-  const query = base.baseQuery.clone();
-  const u = args.map(
-    (a) => ({
-      a: prepareSubQueryForSql(
-        base,
-        typeof a === "function" ? a(query) : a
-      ),
-      k,
-      m
-    })
-  );
-  const { q } = query;
-  const baseQ = base.q;
-  q.union = baseQ.union ? {
-    ...baseQ.union,
-    u: [...baseQ.union.u, ...u]
-  } : {
-    b: base,
-    u,
-    p
-  };
-  return query;
-};
-class Union {
   /**
-   * Creates a union query, takes one or more queries or SQL expressions.
-   *
-   * ```ts
-   * import { sql } from './baseTable';
-   *
-   * // The first query of the union
-   * db.one
-   *   .select('id', 'name')
-   *   // add two more queries to the union
-   *   .union(
-   *     db.two.select('id', 'name'),
-   *     (q = sql`SELECT id, name FROM "thirdTable"`),
-   *   )
-   *   // sub-sequent `union` is equivalent to passing multiple queries into a single `union`
-   *   .union(db.three.select('id', 'name'));
-   * ```
+   * Run the function after any kind of query.
+   * Enforces wrapping the query into a transaction.
+   * The function will run after the query is succeeded, but before the transaction commit.
    *
-   * `order`, `limit`, `offset` are special, it matters if you place them **before** or **after** the `union`, it also have a meaning to place them before and after.
+   * @param cb - function to call, first argument is the query result of type `unknown`, second argument is a query object
+   */
+  afterQuery(cb) {
+    return _queryHookAfterQuery(_clone(this), cb);
+  }
+  /**
+   * Run the function before a `create` kind of query.
    *
-   * ```ts
-   * // order, limit, offset are applied ONLY to 'one'
-   * db.one
-   *   .order('x')
-   *   .limit(1)
-   *   .offset(1)
-   *   // 'two' also has order, limit, and offset
-   *   .unionAll(db.two.order('y').limit(2).offset(2))
-   *   // sets order, limit, offset for all records
-   *   .order('z')
-   *   .limit(3)
-   *   .offset(3);
-   * ```
+   * @param cb - function to call, first argument is a query object
+   */
+  beforeCreate(cb) {
+    return _queryHookBeforeCreate(_clone(this), cb);
+  }
+  /**
+   * Run the function after a `create` kind of query.
+   * Enforces wrapping the query into a transaction.
+   * The function will run after the query is succeeded, but before the transaction commit.
+   * Queries inside the function will run in the same transaction as the target query.
    *
-   * Equivalent SQL:
+   * @param select - list of columns to select for the hook
+   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+   */
+  afterCreate(select, cb) {
+    return _queryHookAfterCreate(_clone(this), select, cb);
+  }
+  /**
+   * Run the function after transaction for a `create` kind of query will be committed.
+   * If the query wasn't wrapped in a transaction, will run after the query.
    *
-   * ```sql
-   * -- both union parts have their own order, limit, offset
-   * ( SELECT * FROM one ORDER x ASC LIMIT 1 OFFSET 1 )
-   * UNION ALL
-   * ( SELECT * FROM two ORDER y ASC LIMIT 2 OFFSET 2 )
-   * -- order, limit, offset of the whole query
-   * ORDER BY z ASC LIMIT 3 OFFSET 3
-   * ```
+   * @param select - list of columns to select for the hook
+   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+   */
+  afterCreateCommit(select, cb) {
+    return _queryHookAfterCreateCommit(
+      _clone(this),
+      select,
+      cb
+    );
+  }
+  /**
+   * Run the function before an `update` kind of query.
    *
-   * All the listed methods have the same signature, they are only different by SQL keyword:
+   * @param cb - function to call, first argument is a query object
+   */
+  beforeUpdate(cb) {
+    return _queryHookBeforeUpdate(_clone(this), cb);
+  }
+  /**
+   * Run the function after an `update` kind of query.
+   * Enforces wrapping the query into a transaction.
+   * The function will run after the query is succeeded, but before the transaction commit.
+   * Queries inside the function will run in the same transaction as the target query.
+   * If no records were updated, the hook *won't* run.
    *
-   * - `union` - union of all queries, performs deduplication
-   * - `unionAll` - `union` that allows duplicated rows
-   * - `intersect` - get only rows that are present in all queries
-   * - `intersectAll` - `intersect` that allows duplicated rows
-   * - `except` - get only rows that are in the first query but not in the second
-   * - `exceptAll` - `except` that allows duplicated rows
+   * @param select - list of columns to select for the hook
+   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+   */
+  afterUpdate(select, cb) {
+    return _queryHookAfterUpdate(_clone(this), select, cb);
+  }
+  /**
+   * Run the function after transaction for an `update` kind of query will be committed.
+   * If the query wasn't wrapped in a transaction, will run after the query.
+   * If no records were updated, the hook *won't* run.
    *
-   * @param args - array of queries or SQL expressions
+   * @param select - list of columns to select for the hook
+   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
-  union(...args) {
-    return _queryUnion(
+  afterUpdateCommit(select, cb) {
+    return _queryHookAfterUpdateCommit(
       _clone(this),
-      args,
-      "UNION"
+      select,
+      cb
     );
   }
   /**
-   * Same as {@link union}, but allows duplicated rows.
+   * Run the function before a `create` or an `update` kind of query.
    *
-   * @param args - array of queries or SQL expressions
+   * @param cb - function to call, first argument is a query object
    */
-  unionAll(...args) {
-    return _queryUnion(
-      _clone(this),
-      args,
-      "UNION ALL"
-    );
+  beforeSave(cb) {
+    return _queryHookBeforeSave(_clone(this), cb);
   }
   /**
-   * Same as {@link union}, but uses a `INTERSECT` SQL keyword instead
+   * Run the function after a `create` or an `update` kind of query.
+   * Enforces wrapping the query into a transaction.
+   * The function will run after the query is succeeded, but before the transaction commit.
+   * Queries inside the function will run in the same transaction as the target query.
+   * For the `update` query, if no records were updated, the hook *won't* run.
    *
-   * @param args - array of queries or SQL expressions
+   * @param select - list of columns to select for the hook
+   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
-  intersect(...args) {
-    return _queryUnion(
-      _clone(this),
-      args,
-      "INTERSECT"
-    );
+  afterSave(select, cb) {
+    return _queryHookAfterSave(_clone(this), select, cb);
   }
   /**
-   * Same as {@link intersect}, but allows duplicated rows.
+   * Run the function after transaction for a `create` or an `update` kind of query will be committed.
+   * If the query wasn't wrapped in a transaction, will run after the query.
+   * For the `update` query, if no records were updated, the hook *won't* run.
    *
-   * @param args - array of queries or SQL expressions
+   * @param select - list of columns to select for the hook
+   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
-  intersectAll(...args) {
-    return _queryUnion(
-      _clone(this),
-      args,
-      "INTERSECT ALL"
-    );
+  afterSaveCommit(select, cb) {
+    return _queryAfterSaveCommit(_clone(this), select, cb);
   }
   /**
-   * Same as {@link union}, but uses an `EXCEPT` SQL keyword instead
+   * Run the function before a `delete` kind of query.
    *
-   * @param args - array of queries or SQL expressions
+   * @param cb - function to call, first argument is a query object
    */
-  except(...args) {
-    return _queryUnion(
-      _clone(this),
-      args,
-      "EXCEPT"
-    );
+  beforeDelete(cb) {
+    return _queryHookBeforeDelete(_clone(this), cb);
   }
   /**
-   * Same as {@link except}, but allows duplicated rows.
+   * Run the function after a `delete` kind of query.
+   * Enforces wrapping the query into a transaction.
+   * The function will run after the query is succeeded, but before the transaction commit.
+   * Queries inside the function will run in the same transaction as the target query.
+   * If no records were deleted, the hook *won't* run.
    *
-   * @param args - array of queries or SQL expressions
+   * @param select - list of columns to select for the hook
+   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
    */
-  exceptAll(...args) {
-    return _queryUnion(
+  afterDelete(select, cb) {
+    return _queryHookAfterDelete(_clone(this), select, cb);
+  }
+  /**
+   * Run the function after transaction for a `delete` kind of query will be committed.
+   * If the query wasn't wrapped in a transaction, will run after the query.
+   * If no records were deleted, the hook *won't* run.
+   *
+   * @param select - list of columns to select for the hook
+   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+   */
+  afterDeleteCommit(select, cb) {
+    return _queryHookAfterDeleteCommit(
       _clone(this),
-      args,
-      "EXCEPT ALL"
+      select,
+      cb
     );
   }
-}
-
+  /**
+   * Add `catchAfterCommitError` to the query to catch possible errors that are coming from after commit hooks.
+   *
+   * When it is used, the transaction will return its result disregarding of a failed hook.
+   *
+   * Without `catchAfterCommitError`, the transaction function throws and won't return result.
+   * Result is still accessible from the error object [AfterCommitError](#AfterCommitError).
+   *
+   * ```ts
+   * const result = await db
+   *   .$transaction(async () => {
+   *     return db.table.create(data);
+   *   })
+   *   .catchAfterCommitError((err) => {
+   *     // err is instance of AfterCommitError (see below)
+   *   })
+   *   // can be added multiple times, all catchers will be executed
+   *   .catchAfterCommitError((err) => {});
+   *
+   * // result is available even if an after commit hook has failed
+   * result.id;
+   * ```
+   */
+  catchAfterCommitError(fn) {
+    const q = _clone(this);
+    pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
+    return q;
+  }
+}
+
 const setParserToQuery = (query, key, parser) => {
   if (parser) {
     if (query.parsers) query.parsers[key] = parser;
@@ -3914,6 +3888,94 @@ const getQueryParsers = (q, hookSelect) => {
   return q.q.select ? q.q.parsers : q.q.defaultParsers;
 };
 
+const queryColumnNameToKey = (q, name) => {
+  let map = q.internal.columnNameToKeyMap;
+  if (!map) {
+    q.internal.columnNameToKeyMap = map = /* @__PURE__ */ new Map();
+    const { shape } = q;
+    for (const key in q.shape) {
+      const column = shape[key];
+      map.set(column.data.name ?? key, key);
+    }
+  }
+  return map.get(name);
+};
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var _query, _query2, _columnsCache;
+class OrchidOrmError extends Error {
+}
+class NotFoundError extends OrchidOrmError {
+  constructor(query, message = "Record is not found") {
+    super(message);
+    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
+    // it is exposed with `getQuery` method which prevents this problem from both Vitest and Jest.
+    // Exposing it with `get query()` still leaves the issue in Vitest.
+    __privateAdd(this, _query);
+    __privateSet(this, _query, query);
+  }
+  getQuery() {
+    return __privateGet(this, _query);
+  }
+}
+_query = new WeakMap();
+class OrchidOrmInternalError extends Error {
+  constructor(query, message, data) {
+    super(message);
+    this.data = data;
+    // `#query` is private to prevent it from serializing to not cause problems to test runner reports
+    // it is exposed with `getQuery` method which prevents this problem from both Vitest and Jest.
+    // Exposing it with `get query()` still leaves the issue in Vitest.
+    __privateAdd(this, _query2);
+    __privateSet(this, _query2, query);
+  }
+  getQuery() {
+    return __privateGet(this, _query2);
+  }
+}
+_query2 = new WeakMap();
+class QueryError extends OrchidOrmInternalError {
+  constructor() {
+    super(...arguments);
+    __privateAdd(this, _columnsCache);
+  }
+  get isUnique() {
+    return this.code === "23505";
+  }
+  get columns() {
+    if (__privateGet(this, _columnsCache)) return __privateGet(this, _columnsCache);
+    const columns = {};
+    if (this.detail) {
+      const list = this.detail.match(/\((.*)\)=/)?.[1];
+      if (list) {
+        list.split(", ").forEach((item) => {
+          const column = item.startsWith('"') ? item.slice(1, -1) : item;
+          const key = queryColumnNameToKey(this.getQuery(), column) ?? column;
+          columns[key] = true;
+        });
+      }
+    }
+    return __privateSet(this, _columnsCache, columns);
+  }
+}
+_columnsCache = new WeakMap();
+class MoreThanOneRowError extends OrchidOrmInternalError {
+  constructor(query, message) {
+    super(query, message);
+  }
+}
+class UnhandledTypeError extends OrchidOrmInternalError {
+  constructor(query, value) {
+    super(query, `Unhandled type: ${JSON.stringify(value)} received`);
+  }
+}
+
 const escape = (value, migration, nested) => {
   const type = typeof value;
   if (type === "number" || type === "bigint") return String(value);
@@ -4165,525 +4227,177 @@ class QueryTransaction {
       } finally {
         state.transactionId = transactionId - 1;
       }
-    }
-  }
-  /**
-   * Use the `$ensureTransaction` when you want to ensure the sequence of queries is running in a transaction, but there is no need for Postgres [savepoints](https://www.postgresql.org/docs/current/sql-savepoint.html).
-   *
-   * ```ts
-   * async function updateUserBalance(userId: string, amount: number) {
-   *   await db.$ensureTransaction(async () => {
-   *     await db.transfer.create({ userId, amount })
-   *     await db.user.find(userId).increment({ balance: amount })
-   *   })
-   * }
-   *
-   * async function saveDeposit(userId: string, deposit: { ... }) {
-   *   await db.$ensureTransaction(async () => {
-   *     await db.deposit.create(deposit)
-   *     // transaction in updateUserBalance won't be started
-   *     await updateUserBalance(userId, deposit.amount)
-   *   })
-   * }
-   * ```
-   */
-  ensureTransaction(cb) {
-    const trx = this.internal.asyncStorage.getStore();
-    if (trx) return cb();
-    return QueryTransaction.prototype.transaction.call(this, cb);
-  }
-  isInTransaction() {
-    const trx = this.internal.asyncStorage.getStore();
-    return isInUserTransaction(trx);
-  }
-  /**
-   * Schedules a hook to run after the outermost transaction commits:
-   *
-   * ```ts
-   * await db.$transaction(async () => {
-   *   await db.table.create(data)
-   *   await db.table.where({ ...conditions }).update({ key: 'value' })
-   *
-   *   db.$afterCommit(() => { // can be sync or async
-   *     console.log('after commit')
-   *   })
-   * })
-   * ```
-   *
-   * If used outside the transaction, the hook will be executed almost immediately, on the next microtask:
-   *
-   * ```ts
-   * db.$afterCommit(async () => { // can be sync or async
-   *   console.log('after commit')
-   * })
-   * ```
-   *
-   * If the callback has no `try/catch` and throws an error,
-   * this will cause `uncaughtException` if the callback is sync and `unhandledRejection` if it is async.
-   */
-  afterCommit(hook) {
-    const trx = this.internal.asyncStorage.getStore();
-    if (isInUserTransaction(trx)) {
-      (trx.afterCommit ?? (trx.afterCommit = [])).push(hook);
-    } else {
-      queueMicrotask(hook);
-    }
-  }
-  /**
-   * Whenever a query in a transaction fails, the transaction is transitioned to a failed state, no further queries are possible.
-   *
-   * Use [catchUniqueError](/guide/error-handling.html#catchuniqueerror) to handle uniqueness errors,
-   * the following examples do not use it to illustrate error handling.
-   *
-   * ```ts
-   * // This transaction is going to fail
-   * db.$transaction(async () => {
-   *   try {
-   *     // imagine it fails because the username is already taken
-   *     await db.user.insert({ username: 'taken' });
-   *   } catch (err) {
-   *     // even though the query is wrapped in a try-catch, the transaction fails anyway
-   *   }
-   * });
-   * ```
-   *
-   * You can use `catch` method on a query instead of `try-catch` to surpass the problem.
-   * The following transaction won't fail:
-   *
-   * ```ts
-   * // Transaction succeeds
-   * db.$transaction(async () => {
-   *   const result = await db.user.insert({ username: 'taken' }).catch(() => 'failed');
-   *
-   *   if (result === 'failed') {
-   *     await db.user.insert({ username: 'another' });
-   *   }
-   * });
-   * ```
-   *
-   * This is because when using `catch` method, `OrchidORM` will wrap the query with a savepoint.
-   *
-   * Alternatively, you can use the `recoverable()` method:
-   *
-   * ```ts
-   * // Transaction succeeds
-   * db.$transaction(async () => {
-   *   try {
-   *     await db.user.insert({ username: 'taken' }).recoverable();
-   *   } catch (err) {
-   *     await db.user.insert({ username: 'another' });
-   *   }
-   * });
-   * ```
-   */
-  recoverable() {
-    const q = _clone(this);
-    q.q.catch = true;
-    return q;
-  }
-}
-const runAfterCommit = (afterCommit, result) => {
-  queueMicrotask(async () => {
-    if (afterCommit) {
-      const promises = [];
-      let catchAfterCommitErrors;
-      for (let i = 0, len = afterCommit.length; i < len; ) {
-        const first = afterCommit[i];
-        if (typeof first === "function") {
-          try {
-            promises.push(first());
-          } catch (err) {
-            promises.push(Promise.reject(err));
-          }
-          i++;
-        } else {
-          const q = afterCommit[i + 1];
-          if (q.q.catchAfterCommitErrors) {
-            (catchAfterCommitErrors ?? (catchAfterCommitErrors = [])).push(...q.q.catchAfterCommitErrors);
-          }
-          for (const fn of afterCommit[i + 2]) {
-            try {
-              promises.push(fn(first, q));
-            } catch (err) {
-              promises.push(Promise.reject(err));
-            }
-          }
-          i += 3;
-        }
-      }
-      const getHookNames = () => {
-        const hookNames = [];
-        for (let i = 0, len = afterCommit.length; i < len; ) {
-          const first = afterCommit[i];
-          if (typeof first === "function") {
-            hookNames.push(first.name);
-            i++;
-          } else {
-            for (const fn of afterCommit[i + 2]) {
-              hookNames.push(fn.name);
-            }
-            i += 3;
-          }
-        }
-        return hookNames;
-      };
-      await _runAfterCommitHooks(
-        result,
-        promises,
-        getHookNames,
-        catchAfterCommitErrors
-      );
-    }
-  });
-};
-
-const before = (q, key, cb) => pushQueryValueImmutable(q, `before${key}`, cb);
-const after = (query, key, select, cb, commit) => {
-  const q = query;
-  pushQueryValueImmutable(
-    q,
-    `after${key}${commit ? "Commit" : ""}`,
-    cb
-  );
-  if (key === "Save") {
-    addSelect(q, "Create", select);
-    addSelect(q, "Update", select);
-  } else {
-    addSelect(q, key, select);
-  }
-  return query;
-};
-const addSelect = (q, key, select) => {
-  const prop = `after${key}Select`;
-  const set = q.q[prop] = new Set(q.q[prop]);
-  for (const column of select) {
-    set.add(column);
-  }
-};
-const _queryHookBeforeQuery = (q, cb) => {
-  return pushQueryValueImmutable(q, "before", cb);
-};
-const _queryHookAfterQuery = (q, cb) => {
-  return pushQueryValueImmutable(q, "after", cb);
-};
-const _hookSelectColumns = (query, columns, asFn) => {
-  const hookSelect = query.q.hookSelect = new Map(
-    query.q.hookSelect && [...query.q.hookSelect]
-  );
-  const aliases = [];
-  const addAlias = (as) => {
-    aliases.push(as);
-    if (aliases.length === columns.length) {
-      asFn(aliases);
-    }
-  };
-  for (const column of columns) {
-    const item = hookSelect.get(column);
-    hookSelect.set(column, {
-      ...item,
-      select: column,
-      onAs: [...item?.onAs || emptyArray, addAlias]
-    });
-  }
-};
-class QueryHookUtils {
-  constructor(query, columns, key) {
-    this.query = query;
-    this.columns = columns;
-    this.key = key;
-    this.set = (data) => {
-      const set = {};
-      for (const key in data) {
-        if (data[key] !== void 0) {
-          set[key] = data[key];
-        }
-      }
-      pushQueryValueImmutable(this.query, this.key, set);
-    };
-  }
-}
-const finalizeNestedHookSelect = (batches, returnType, tempColumns, renames, key) => {
-  if (renames) {
-    for (const { data } of batches) {
-      for (const record of data) {
-        if (record) {
-          for (const a in renames) {
-            record[a] = record[renames[a]];
-          }
-        }
-      }
-    }
-  }
-  if (tempColumns?.size) {
-    for (const { data } of batches) {
-      for (const record of data) {
-        if (record) {
-          for (const key2 of tempColumns) {
-            delete record[key2];
-          }
-        }
-      }
-    }
-  }
-  if (returnType === "one" || returnType === "oneOrThrow") {
-    for (const batch of batches) {
-      batch.data = batch.data[0];
-    }
-  } else if (returnType === "pluck") {
-    for (const { data } of batches) {
-      for (let i = 0; i < data.length; i++) {
-        data[i] = data[i][key];
-      }
-    }
-  } else if (returnType === "value" || returnType === "valueOrThrow") {
-    for (const item of batches) {
-      item.parent[item.key] = item.data[0]?.[key];
-    }
-  }
-};
-const _queryHookBeforeCreate = (q, cb) => {
-  return before(
-    q,
-    "Create",
-    (q2) => cb(new QueryHookUtils(q2, q2.q.columns, "hookCreateSet"))
-  );
-};
-const _queryHookAfterCreate = (q, select, cb) => {
-  return after(q, "Create", select, cb);
-};
-const _queryHookAfterCreateCommit = (q, select, cb) => {
-  return after(q, "Create", select, cb, true);
-};
-const _queryHookBeforeUpdate = (q, cb) => {
-  return before(q, "Update", (q2) => {
-    const columns = /* @__PURE__ */ new Set();
-    if (q2.q.updateData) {
-      for (const item of q2.q.updateData) {
-        if (typeof item === "object") {
-          for (const key in item) {
-            columns.add(key);
-          }
-        }
-      }
-    }
-    if (q2.q.updateMany) {
-      for (const key of q2.q.updateMany.setColumns) {
-        columns.add(key);
-      }
-    }
-    return cb(new QueryHookUtils(q2, [...columns], "hookUpdateSet"));
-  });
-};
-const _queryHookAfterUpdate = (q, select, cb) => {
-  return after(q, "Update", select, cb);
-};
-const _queryHookAfterUpdateCommit = (q, select, cb) => {
-  return after(q, "Update", select, cb, true);
-};
-const _queryHookBeforeSave = (q, cb) => {
-  return _queryHookBeforeUpdate(_queryHookBeforeCreate(q, cb), cb);
-};
-const _queryHookAfterSave = (q, select, cb) => {
-  return after(q, "Save", select, cb);
-};
-const _queryAfterSaveCommit = (q, select, cb) => {
-  return after(q, "Save", select, cb, true);
-};
-const _queryHookBeforeDelete = (q, cb) => {
-  return before(q, "Delete", cb);
-};
-const _queryHookAfterDelete = (q, select, cb) => {
-  return after(q, "Delete", select, cb);
-};
-const _queryHookAfterDeleteCommit = (q, select, cb) => {
-  return after(q, "Delete", select, cb, true);
-};
-class QueryHooks {
-  /**
-   * Run the function before any kind of query.
-   *
-   * @param cb - function to call, first argument is a query object
-   */
-  beforeQuery(cb) {
-    return _queryHookBeforeQuery(_clone(this), cb);
-  }
-  /**
-   * Run the function after any kind of query.
-   * Enforces wrapping the query into a transaction.
-   * The function will run after the query is succeeded, but before the transaction commit.
-   *
-   * @param cb - function to call, first argument is the query result of type `unknown`, second argument is a query object
-   */
-  afterQuery(cb) {
-    return _queryHookAfterQuery(_clone(this), cb);
-  }
-  /**
-   * Run the function before a `create` kind of query.
-   *
-   * @param cb - function to call, first argument is a query object
-   */
-  beforeCreate(cb) {
-    return _queryHookBeforeCreate(_clone(this), cb);
+    }
   }
   /**
-   * Run the function after a `create` kind of query.
-   * Enforces wrapping the query into a transaction.
-   * The function will run after the query is succeeded, but before the transaction commit.
-   * Queries inside the function will run in the same transaction as the target query.
+   * Use the `$ensureTransaction` when you want to ensure the sequence of queries is running in a transaction, but there is no need for Postgres [savepoints](https://www.postgresql.org/docs/current/sql-savepoint.html).
    *
-   * @param select - list of columns to select for the hook
-   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
-   */
-  afterCreate(select, cb) {
-    return _queryHookAfterCreate(_clone(this), select, cb);
-  }
-  /**
-   * Run the function after transaction for a `create` kind of query will be committed.
-   * If the query wasn't wrapped in a transaction, will run after the query.
+   * ```ts
+   * async function updateUserBalance(userId: string, amount: number) {
+   *   await db.$ensureTransaction(async () => {
+   *     await db.transfer.create({ userId, amount })
+   *     await db.user.find(userId).increment({ balance: amount })
+   *   })
+   * }
    *
-   * @param select - list of columns to select for the hook
-   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+   * async function saveDeposit(userId: string, deposit: { ... }) {
+   *   await db.$ensureTransaction(async () => {
+   *     await db.deposit.create(deposit)
+   *     // transaction in updateUserBalance won't be started
+   *     await updateUserBalance(userId, deposit.amount)
+   *   })
+   * }
+   * ```
    */
-  afterCreateCommit(select, cb) {
-    return _queryHookAfterCreateCommit(
-      _clone(this),
-      select,
-      cb
-    );
+  ensureTransaction(cb) {
+    const trx = this.internal.asyncStorage.getStore();
+    if (trx) return cb();
+    return QueryTransaction.prototype.transaction.call(this, cb);
   }
-  /**
-   * Run the function before an `update` kind of query.
-   *
-   * @param cb - function to call, first argument is a query object
-   */
-  beforeUpdate(cb) {
-    return _queryHookBeforeUpdate(_clone(this), cb);
+  isInTransaction() {
+    const trx = this.internal.asyncStorage.getStore();
+    return isInUserTransaction(trx);
   }
   /**
-   * Run the function after an `update` kind of query.
-   * Enforces wrapping the query into a transaction.
-   * The function will run after the query is succeeded, but before the transaction commit.
-   * Queries inside the function will run in the same transaction as the target query.
-   * If no records were updated, the hook *won't* run.
+   * Schedules a hook to run after the outermost transaction commits:
    *
-   * @param select - list of columns to select for the hook
-   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
-   */
-  afterUpdate(select, cb) {
-    return _queryHookAfterUpdate(_clone(this), select, cb);
-  }
-  /**
-   * Run the function after transaction for an `update` kind of query will be committed.
-   * If the query wasn't wrapped in a transaction, will run after the query.
-   * If no records were updated, the hook *won't* run.
+   * ```ts
+   * await db.$transaction(async () => {
+   *   await db.table.create(data)
+   *   await db.table.where({ ...conditions }).update({ key: 'value' })
    *
-   * @param select - list of columns to select for the hook
-   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
-   */
-  afterUpdateCommit(select, cb) {
-    return _queryHookAfterUpdateCommit(
-      _clone(this),
-      select,
-      cb
-    );
-  }
-  /**
-   * Run the function before a `create` or an `update` kind of query.
+   *   db.$afterCommit(() => { // can be sync or async
+   *     console.log('after commit')
+   *   })
+   * })
+   * ```
    *
-   * @param cb - function to call, first argument is a query object
-   */
-  beforeSave(cb) {
-    return _queryHookBeforeSave(_clone(this), cb);
-  }
-  /**
-   * Run the function after a `create` or an `update` kind of query.
-   * Enforces wrapping the query into a transaction.
-   * The function will run after the query is succeeded, but before the transaction commit.
-   * Queries inside the function will run in the same transaction as the target query.
-   * For the `update` query, if no records were updated, the hook *won't* run.
+   * If used outside the transaction, the hook will be executed almost immediately, on the next microtask:
    *
-   * @param select - list of columns to select for the hook
-   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
-   */
-  afterSave(select, cb) {
-    return _queryHookAfterSave(_clone(this), select, cb);
-  }
-  /**
-   * Run the function after transaction for a `create` or an `update` kind of query will be committed.
-   * If the query wasn't wrapped in a transaction, will run after the query.
-   * For the `update` query, if no records were updated, the hook *won't* run.
+   * ```ts
+   * db.$afterCommit(async () => { // can be sync or async
+   *   console.log('after commit')
+   * })
+   * ```
    *
-   * @param select - list of columns to select for the hook
-   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
+   * If the callback has no `try/catch` and throws an error,
+   * this will cause `uncaughtException` if the callback is sync and `unhandledRejection` if it is async.
    */
-  afterSaveCommit(select, cb) {
-    return _queryAfterSaveCommit(_clone(this), select, cb);
+  afterCommit(hook) {
+    const trx = this.internal.asyncStorage.getStore();
+    if (isInUserTransaction(trx)) {
+      (trx.afterCommit ?? (trx.afterCommit = [])).push(hook);
+    } else {
+      queueMicrotask(hook);
+    }
   }
   /**
-   * Run the function before a `delete` kind of query.
+   * Whenever a query in a transaction fails, the transaction is transitioned to a failed state, no further queries are possible.
    *
-   * @param cb - function to call, first argument is a query object
-   */
-  beforeDelete(cb) {
-    return _queryHookBeforeDelete(_clone(this), cb);
-  }
-  /**
-   * Run the function after a `delete` kind of query.
-   * Enforces wrapping the query into a transaction.
-   * The function will run after the query is succeeded, but before the transaction commit.
-   * Queries inside the function will run in the same transaction as the target query.
-   * If no records were deleted, the hook *won't* run.
+   * Use [catchUniqueError](/guide/error-handling.html#catchuniqueerror) to handle uniqueness errors,
+   * the following examples do not use it to illustrate error handling.
    *
-   * @param select - list of columns to select for the hook
-   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
-   */
-  afterDelete(select, cb) {
-    return _queryHookAfterDelete(_clone(this), select, cb);
-  }
-  /**
-   * Run the function after transaction for a `delete` kind of query will be committed.
-   * If the query wasn't wrapped in a transaction, will run after the query.
-   * If no records were deleted, the hook *won't* run.
+   * ```ts
+   * // This transaction is going to fail
+   * db.$transaction(async () => {
+   *   try {
+   *     // imagine it fails because the username is already taken
+   *     await db.user.insert({ username: 'taken' });
+   *   } catch (err) {
+   *     // even though the query is wrapped in a try-catch, the transaction fails anyway
+   *   }
+   * });
+   * ```
    *
-   * @param select - list of columns to select for the hook
-   * @param cb - function to call, first argument is the query result with selected columns, second argument is a query object
-   */
-  afterDeleteCommit(select, cb) {
-    return _queryHookAfterDeleteCommit(
-      _clone(this),
-      select,
-      cb
-    );
-  }
-  /**
-   * Add `catchAfterCommitError` to the query to catch possible errors that are coming from after commit hooks.
+   * You can use `catch` method on a query instead of `try-catch` to surpass the problem.
+   * The following transaction won't fail:
    *
-   * When it is used, the transaction will return its result disregarding of a failed hook.
+   * ```ts
+   * // Transaction succeeds
+   * db.$transaction(async () => {
+   *   const result = await db.user.insert({ username: 'taken' }).catch(() => 'failed');
    *
-   * Without `catchAfterCommitError`, the transaction function throws and won't return result.
-   * Result is still accessible from the error object [AfterCommitError](#AfterCommitError).
+   *   if (result === 'failed') {
+   *     await db.user.insert({ username: 'another' });
+   *   }
+   * });
+   * ```
    *
-   * ```ts
-   * const result = await db
-   *   .$transaction(async () => {
-   *     return db.table.create(data);
-   *   })
-   *   .catchAfterCommitError((err) => {
-   *     // err is instance of AfterCommitError (see below)
-   *   })
-   *   // can be added multiple times, all catchers will be executed
-   *   .catchAfterCommitError((err) => {});
+   * This is because when using `catch` method, `OrchidORM` will wrap the query with a savepoint.
    *
-   * // result is available even if an after commit hook has failed
-   * result.id;
+   * Alternatively, you can use the `recoverable()` method:
+   *
+   * ```ts
+   * // Transaction succeeds
+   * db.$transaction(async () => {
+   *   try {
+   *     await db.user.insert({ username: 'taken' }).recoverable();
+   *   } catch (err) {
+   *     await db.user.insert({ username: 'another' });
+   *   }
+   * });
    * ```
    */
-  catchAfterCommitError(fn) {
+  recoverable() {
     const q = _clone(this);
-    pushQueryValueImmutable(q, "catchAfterCommitErrors", fn);
+    q.q.catch = true;
     return q;
   }
 }
+const runAfterCommit = (afterCommit, result) => {
+  queueMicrotask(async () => {
+    if (afterCommit) {
+      const promises = [];
+      let catchAfterCommitErrors;
+      for (let i = 0, len = afterCommit.length; i < len; ) {
+        const first = afterCommit[i];
+        if (typeof first === "function") {
+          try {
+            promises.push(first());
+          } catch (err) {
+            promises.push(Promise.reject(err));
+          }
+          i++;
+        } else {
+          const q = afterCommit[i + 1];
+          if (q.q.catchAfterCommitErrors) {
+            (catchAfterCommitErrors ?? (catchAfterCommitErrors = [])).push(...q.q.catchAfterCommitErrors);
+          }
+          for (const fn of afterCommit[i + 2]) {
+            try {
+              promises.push(fn(first, q));
+            } catch (err) {
+              promises.push(Promise.reject(err));
+            }
+          }
+          i += 3;
+        }
+      }
+      const getHookNames = () => {
+        const hookNames = [];
+        for (let i = 0, len = afterCommit.length; i < len; ) {
+          const first = afterCommit[i];
+          if (typeof first === "function") {
+            hookNames.push(first.name);
+            i++;
+          } else {
+            for (const fn of afterCommit[i + 2]) {
+              hookNames.push(fn.name);
+            }
+            i += 3;
+          }
+        }
+        return hookNames;
+      };
+      await _runAfterCommitHooks(
+        result,
+        promises,
+        getHookNames,
+        catchAfterCommitErrors
+      );
+    }
+  });
+};
 
 const applyTransforms = (queryData, returnType, fns, result) => {
   for (const fn of fns) {
@@ -4940,6 +4654,127 @@ const collectPrimaryKeys = (q) => {
   return primaryKeys;
 };
 
+const _unscope = (q, scope) => {
+  if (q.q.scopes) {
+    q.q.scopes = { ...q.q.scopes };
+    delete q.q.scopes[scope];
+    for (const _ in q.q.scopes) {
+      return q;
+    }
+    delete q.q.scopes;
+  }
+  return q;
+};
+class QueryScope {
+  /**
+   * See {@link QueryScope}
+   *
+   * Use the `scope` method to apply a pre-defined scope.
+   *
+   * ```ts
+   * // use the `active` scope that is defined in the table:
+   * await db.some.scope('active');
+   * ```
+   *
+   * @param scope - name of the scope to apply
+   */
+  scope(scope) {
+    const q = _clone(this);
+    if (!q.q.scopes?.[scope]) {
+      const s = q.internal.scopes[scope];
+      if (!s) throw new Error(`Scope ${scope} is not defined`);
+      setObjectValueImmutable(q.q, "scopes", scope, s);
+    }
+    return q;
+  }
+  /**
+   * See {@link QueryScope}
+   *
+   * Remove conditions that were added by the scope from the query.
+   *
+   * ```ts
+   * // SomeTable has a default scope, ignore it for this query:
+   * await db.some.unscope('default');
+   * ```
+   *
+   * @param scope - name of the scope to remove from the query
+   */
+  unscope(scope) {
+    return _unscope(_clone(this), scope);
+  }
+}
+
+const checkIfNeedResultAllForMutativeQueriesSelectRelations = (sql) => {
+  return sql.mutativeQueriesSelectRelationsState?.value;
+};
+const checkIfShouldReleaseSavepointForMutativeQueriesSelectRelations = (sql) => {
+  return sql.mutativeQueriesSelectRelationsState?.value;
+};
+const loadMutativeQueriesSelectRelations = (sql, result, adapter, startingSavepoint, renames) => sql.mutativeQueriesSelectRelationsState?.value ? loadRelations(
+  sql.mutativeQueriesSelectRelationsState,
+  result,
+  adapter,
+  startingSavepoint,
+  renames
+) : void 0;
+const loadRelations = async (state, result, adapter, startingSavepoint, renames) => {
+  var _a;
+  const q = state.query;
+  const primaryKeys = requirePrimaryKeys(
+    q,
+    "Cannot select a relation of a table that has no primary keys"
+  );
+  const selectQuery = _unscope(q, "nonDeleted");
+  selectQuery.q.type = selectQuery.q.returnType = void 0;
+  const matchSourceTableIds = {};
+  for (const pkey of primaryKeys) {
+    matchSourceTableIds[pkey] = {
+      in: result.map((row) => row[pkey])
+    };
+  }
+  ((_a = selectQuery.q).and ?? (_a.and = [])).push(matchSourceTableIds);
+  const relationsSelect = state.value;
+  const selectAs = { ...relationsSelect };
+  const select = [{ selectAs }];
+  const relationKeyAliases = primaryKeys.map((key) => {
+    if (key in selectAs) {
+      const as = getFreeAlias(selectAs, key);
+      selectAs[as] = key;
+      return as;
+    } else {
+      select.push(key);
+      return key;
+    }
+  });
+  selectQuery.q.select = select;
+  const relationsResult = await maybeWrappedThen.call(
+    selectQuery,
+    void 0,
+    async (err) => {
+      await adapter.arrays(`ROLLBACK TO SAVEPOINT "${startingSavepoint}"`);
+      throw err;
+    },
+    startingSavepoint
+  );
+  for (const row of result) {
+    const relationRow = relationsResult.find((relationRow2) => {
+      return !primaryKeys.some(
+        (key, i) => relationRow2[relationKeyAliases[i]] !== row[key]
+      );
+    });
+    if (relationRow) {
+      Object.assign(row, relationRow);
+    }
+  }
+  if (renames) {
+    for (const key in relationsSelect) {
+      if (key in renames) {
+        delete renames[key];
+      }
+    }
+  }
+};
+
 const queryMethodByReturnType = {
   undefined: "query",
   all: "query",
@@ -4952,7 +4787,6 @@ const queryMethodByReturnType = {
   void: "arrays"
 };
 class Then {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   catch(fn) {
     const q = _clone(this);
     q.q.catch = true;
@@ -4984,7 +4818,7 @@ Object.defineProperty(Then.prototype, "then", {
     });
   }
 });
-function maybeWrappedThen(resolve, reject) {
+function maybeWrappedThen(resolve, reject, parentSavepoint) {
   const { q } = this;
   const shouldCatch = q.catch;
   let beforeActionHooks;
@@ -5039,7 +4873,8 @@ function maybeWrappedThen(resolve, reject) {
           afterSaveCommitHooks,
           resolve2,
           reject2,
-          shouldCatch
+          shouldCatch,
+          parentSavepoint
         );
       })
     ).then(resolve, reject);
@@ -5055,7 +4890,8 @@ function maybeWrappedThen(resolve, reject) {
       afterSaveCommitHooks,
       resolve,
       reject,
-      shouldCatch
+      shouldCatch,
+      parentSavepoint
     );
   }
 }
@@ -5065,8 +4901,7 @@ const callAfterHook = function(cb) {
   return cb(this[0], this[1]);
 };
 const beginSql = { text: "BEGIN" };
-const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks, afterCommitHooks, afterSaveCommitHooks, resolve, reject, shouldCatch) => {
-  var _a;
+const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks, afterCommitHooks, afterSaveCommitHooks, resolve, reject, shouldCatch, parentSavepoint) => {
   const { q: query } = q;
   let sql;
   let logData;
@@ -5090,12 +4925,16 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
       }
       if (promises) await Promise.all(promises);
     }
-    const { tableHook, cteHooks, delayedRelationSelect } = sql;
+    const { tableHook, cteHooks } = sql;
     const { returnType = "all" } = query;
-    const tempReturnType = tableHook?.select || cteHooks?.hasSelect || returnType === "rows" && q.q.batchParsers || delayedRelationSelect?.value ? "all" : returnType;
+    const tempReturnType = tableHook?.select || cteHooks?.hasSelect || returnType === "rows" && q.q.batchParsers || checkIfNeedResultAllForMutativeQueriesSelectRelations(sql) ? "all" : returnType;
     let result;
     let queryResult;
     let cteData;
+    const startingSavepoint = setCatchingSavepoint(
+      !parentSavepoint && shouldCatch && state
+    );
+    const releasingSavepoint = checkIfShouldReleaseSavepointForMutativeQueriesSelectRelations(sql) || parentSavepoint ? void 0 : startingSavepoint;
     if ("text" in sql) {
       if (query.autoPreparedStatements) {
         sql.name = queriesNames[sql.text] || (queriesNames[sql.text] = (nameI++).toString(36));
@@ -5104,7 +4943,13 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
         logData = log.beforeQuery(sql);
       }
       const method = queryMethodByReturnType[tempReturnType];
-      queryResult = await execQuery(adapter, method, sql, shouldCatch && state);
+      queryResult = await execQuery(
+        adapter,
+        method,
+        sql,
+        startingSavepoint,
+        releasingSavepoint
+      );
       const { runAfterQuery } = sql;
       if (log) {
         log.afterQuery(sql, logData);
@@ -5138,8 +4983,9 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
     } else {
       const queryMethod = queryMethodByReturnType[tempReturnType];
       const queryBatch = async (batch) => {
-        for (const item of batch) {
-          sql = item;
+        const last = batch.length - 1;
+        for (let i = 0; i <= last; i++) {
+          sql = batch[i];
           if (log) {
             logData = log.beforeQuery(sql);
           }
@@ -5147,7 +4993,8 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
             adapter,
             queryMethod,
             sql,
-            shouldCatch && state
+            i === 0 ? startingSavepoint : void 0,
+            i === last ? releasingSavepoint : void 0
           );
           if (queryResult) {
             queryResult.rowCount += result2.rowCount;
@@ -5179,8 +5026,11 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
     let tempColumns;
     let renames;
     if (tableHook?.select) {
-      for (const column of tableHook.select.keys()) {
-        const { as, temp } = tableHook.select.get(column);
+      for (const [
+        column,
+        { as, temp, notLoaded }
+      ] of tableHook.select.entries()) {
+        if (notLoaded) continue;
         if (as) {
           (renames ?? (renames = {}))[column] = as;
         }
@@ -5266,7 +5116,7 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
           const afterCommitKey = `after${purpose2}Commit`;
           const afterCommit = tableHook2[afterCommitKey];
           if (afterCommit) {
-            const arr = cteAfterHooks ?? (cteAfterHooks = []);
+            const arr = cteAfterCommitHooks ?? (cteAfterCommitHooks = []);
             for (const fn of afterCommit) {
               const hookData = addedAfterCommitHooks.has(fn);
               if (!hookData) {
@@ -5308,7 +5158,13 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
               afterActionAndSaveCommit
             );
           }
-          if (cteAfterCommitHooks) ;
+          if (cteAfterCommitHooks) {
+            (state.afterCommit ?? (state.afterCommit = [])).push(
+              result,
+              q,
+              cteAfterCommitHooks
+            );
+          }
         } else {
           const localResult = result;
           queueMicrotask(async () => {
@@ -5324,7 +5180,15 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
                 }
               }
             }
-            if (cteAfterCommitHooks) ;
+            if (cteAfterCommitHooks) {
+              for (const fn of cteAfterCommitHooks) {
+                try {
+                  promises.push(fn());
+                } catch (err) {
+                  promises.push(Promise.reject(err));
+                }
+              }
+            }
             await _runAfterCommitHooks(
               localResult,
               promises,
@@ -5338,56 +5202,22 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
         }
       }
     }
-    if (delayedRelationSelect?.value) {
-      const q2 = delayedRelationSelect.query;
-      const primaryKeys = requirePrimaryKeys(
-        q2,
-        "Cannot select a relation of a table that has no primary keys"
-      );
-      const selectQuery = q2.clone();
-      selectQuery.q.type = selectQuery.q.returnType = void 0;
-      const matchSourceTableIds = {};
-      for (const pkey of primaryKeys) {
-        matchSourceTableIds[pkey] = {
-          in: result.map((row) => row[pkey])
-        };
-      }
-      ((_a = selectQuery.q).and ?? (_a.and = [])).push(matchSourceTableIds);
-      const relationsSelect = delayedRelationSelect.value;
-      const selectAs = { ...relationsSelect };
-      const select = [{ selectAs }];
-      const relationKeyAliases = primaryKeys.map((key) => {
-        if (key in selectAs) {
-          const as = getFreeAlias(selectAs, key);
-          selectAs[as] = key;
-          return as;
-        } else {
-          select.push(key);
-          return key;
-        }
-      });
-      selectQuery.q.select = select;
-      const relationsResult = await selectQuery;
-      for (const row of result) {
-        const relationRow = relationsResult.find((relationRow2) => {
-          return !primaryKeys.some(
-            (key, i) => relationRow2[relationKeyAliases[i]] !== row[key]
-          );
-        });
-        if (relationRow) {
-          Object.assign(row, relationRow);
-        }
-      }
-      if (renames) {
-        for (const key in relationsSelect) {
-          if (key in renames) {
-            delete renames[key];
-          }
-        }
-      }
+    const promise = loadMutativeQueriesSelectRelations(
+      localSql,
+      result,
+      adapter,
+      startingSavepoint,
+      renames
+    ) || /**
+     * In case when we have MutativeQueriesSelectRelations, the first query does insert/update/delete,
+     * it must not run batchParsers because it doesn't have the data yet.
+     * The second query loads data and performs batchParsers.
+     */
+    //
+    parseBatch(q, queryResult);
+    if (promise) {
+      await promise;
     }
-    const promise = parseBatch(q, queryResult, delayedRelationSelect);
-    if (promise) await promise;
     if (tableHook?.select || tempReturnType !== returnType) {
       if (renames) {
         const renamedResult = Array.from({
@@ -5406,7 +5236,7 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
       result = filterResult(
         q,
         returnType,
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        //
         queryResult,
         result,
         tempColumns,
@@ -5453,12 +5283,15 @@ const then = async (q, adapter, state, beforeHooks, afterHooks, afterSaveHooks,
     throw error;
   }
 };
-const execQuery = (adapter, method, sql, catchTrx) => {
-  const catchingSavepoint = catchTrx ? `s${catchTrx.catchI = (catchTrx.catchI || 0) + 1}` : void 0;
+const setCatchingSavepoint = (catchTrx) => {
+  return catchTrx ? `s${catchTrx.catchI = (catchTrx.catchI || 0) + 1}` : void 0;
+};
+const execQuery = (adapter, method, sql, startingSavepoint, releasingSavepoint) => {
   return adapter[method](
     sql.text,
     sql.values,
-    catchingSavepoint
+    startingSavepoint,
+    releasingSavepoint
   ).then((result) => {
     if (result.rowCount && !result.rows.length) {
       result.rows.length = result.rowCount;
@@ -5525,9 +5358,9 @@ const handleResult = (q, returnType, result, sql, isSubQuery) => {
     }
   }
 };
-const parseBatch = (q, queryResult, delayedRelationSelect) => {
+const parseBatch = (q, queryResult) => {
   let promises;
-  if (q.q.batchParsers && !delayedRelationSelect?.value) {
+  if (q.q.batchParsers) {
     for (const parser of q.q.batchParsers) {
       const res = parser.fn(parser.path, queryResult);
       if (res) (promises ?? (promises = [])).push(res);
@@ -5617,27 +5450,193 @@ const getFirstResultKey = (q, queryResult) => {
       return key;
     }
   }
-  return;
+  return;
+};
+const filterAllResult = (result, tempColumns, hasAfterHook) => {
+  if (tempColumns?.size) {
+    if (hasAfterHook) {
+      return result.map((data) => {
+        const record = { ...data };
+        for (const key of tempColumns) {
+          delete record[key];
+        }
+        return record;
+      });
+    } else {
+      for (const record of result) {
+        for (const key of tempColumns) {
+          delete record[key];
+        }
+      }
+    }
+  }
+  return result;
+};
+
+const getQueryAs = (q) => {
+  return q.q.as || q.table;
+};
+const _getQueryAs = (q) => q.q.as;
+const _getQueryFreeAlias = (q, as) => q.aliases ? getFreeAlias(q.aliases, as) : as;
+const _checkIfAliased = (q, as, name) => {
+  return q.q.aliases?.[as] === name;
+};
+const _getQueryAliasOrName = (q, as) => {
+  return q.aliases?.[as] || as;
+};
+const _getQueryOuterAliases = (q) => {
+  return q.outerAliases;
+};
+const _setQueryAs = (self, as) => {
+  const { q } = self;
+  q.as = as;
+  q.aliases = {
+    ...q.aliases,
+    [as]: _getQueryFreeAlias(q, as)
+  };
+  return self;
+};
+const _setQueryAlias = (q, name, as) => {
+  q.q.aliases = { ...q.q.aliases, [as]: name };
+};
+const _setSubQueryAliases = (q) => {
+  q.q.outerAliases = q.q.aliases;
+};
+const _applyRelationAliases = (query, relQueryData) => {
+  const aliases = query.q.as ? { ...query.q.aliases } : { ...query.q.aliases, [query.table]: query.table };
+  const relAliases = relQueryData.aliases;
+  for (const as in relAliases) {
+    aliases[as] = getFreeAlias(aliases, as);
+  }
+  relQueryData.as = aliases[relQueryData.as];
+  relQueryData.aliases = aliases;
+};
+const _copyQueryAliasToQuery = (fromQuery, toQuery, key) => {
+  const name = _getQueryAliasOrName(fromQuery.q, key);
+  if (name !== key) {
+    _setQueryAlias(toQuery, name, key);
+  }
+  return name;
+};
+class QueryAsMethods {
+  /**
+   * Sets table alias:
+   *
+   * ```ts
+   * db.table.as('u').select('u.name');
+   *
+   * // Can be used in the join:
+   * db.table.join(db.profile.as('p'), 'p.userId', 'user.id');
+   * ```
+   *
+   * @param as - alias for the table of this query
+   */
+  as(as) {
+    return _setQueryAs(_clone(this), as);
+  }
+}
+
+const pushQueryArrayImmutable = (q, key, value) => {
+  const arr = q.q[key];
+  q.q[key] = arr ? [...arr, ...value] : value;
+  return q;
+};
+const setQueryObjectValueImmutable = (q, object, key, value) => {
+  q.q[object] = {
+    ...q.q[object],
+    [key]: value
+  };
+  return q;
+};
+const throwIfNoWhere = (q, method) => {
+  if (!q.q.or && !q.q.and && !q.q.scopes && !q.q.all) {
+    throw new OrchidOrmInternalError(
+      q,
+      `Dangerous ${method} without conditions`
+    );
+  }
+};
+const throwIfJoinLateral = (q, method) => {
+  if (q.q.join?.some((x) => Array.isArray(x) || "s" in x.args && x.args.s)) {
+    throw new OrchidOrmInternalError(
+      q,
+      `Cannot join a complex query in ${method}`
+    );
+  }
+};
+const throwOnReadOnlyUpdate = (query, column, key) => {
+  if (column.data.appReadOnly || column.data.readOnly) {
+    throw new OrchidOrmInternalError(
+      query,
+      "Trying to update a readonly column",
+      { column: key }
+    );
+  }
+};
+const saveAliasedShape = (q, as, key) => {
+  const shapes = q.q[key];
+  as = getFreeAlias(shapes, as);
+  setQueryObjectValueImmutable(q, key, as, emptyObject);
+  return as;
+};
+const extendQuery = (q, methods) => {
+  const base = Object.create(q.baseQuery);
+  base.baseQuery = base;
+  Object.assign(base, methods);
+  const cloned = Object.create(base);
+  cloned.q = getClonedQueryData(q.q);
+  return cloned;
+};
+const _queryAll = (q) => {
+  q.q.returnType = "all";
+  q.q.all = true;
+  return q;
+};
+const _queryTake = (query) => {
+  const q = query.q;
+  switch (q.returnType) {
+    case "valueOrThrow":
+    case "pluck":
+    case "void":
+      break;
+    case "value": {
+      q.returnType = "valueOrThrow";
+      break;
+    }
+    default: {
+      q.returnType = "oneOrThrow";
+    }
+  }
+  return query;
 };
-const filterAllResult = (result, tempColumns, hasAfterHook) => {
-  if (tempColumns?.size) {
-    if (hasAfterHook) {
-      return result.map((data) => {
-        const record = { ...data };
-        for (const key of tempColumns) {
-          delete record[key];
-        }
-        return record;
-      });
-    } else {
-      for (const record of result) {
-        for (const key of tempColumns) {
-          delete record[key];
-        }
-      }
+const _queryTakeOptional = (query) => {
+  const q = query.q;
+  switch (q.returnType) {
+    case "value":
+    case "pluck":
+    case "void":
+      break;
+    case "valueOrThrow": {
+      q.returnType = "value";
+      break;
+    }
+    default: {
+      q.returnType = "one";
     }
   }
-  return result;
+  return query;
+};
+const _queryExec = (q) => {
+  q.q.returnType = "void";
+  return q;
+};
+const _queryRows = (q) => {
+  q.q.returnType = "rows";
+  return q;
+};
+const getFullColumnTable = (q, column, index, as) => {
+  const table = column.slice(0, index);
+  return as && table !== as && _checkIfAliased(q, table, as) ? as : table;
 };
 
 const noneResult = (q, queryData, type) => {
@@ -5687,6 +5686,38 @@ const _queryNone = (q) => {
 };
 const isQueryNone = (q) => q.then === noneMethods.then;
 
+const prepareSubQueryForSql = (mainQuery, subQuery) => {
+  if (subQuery.dynamicBefore) {
+    pushQueryValueImmutable(mainQuery, "dynamicBefore", subQuery.q);
+    return subQuery;
+  }
+  let beforeAction = subQuery.q.type ? subQuery.q.type === "insert" ? subQuery.q.beforeCreate : subQuery.q.type === "update" ? subQuery.q.beforeUpdate : subQuery.q.type === "upsert" ? subQuery.q.upsertUpdate && subQuery.q.updateData ? subQuery.q.beforeUpdate && subQuery.q.beforeCreate ? [...subQuery.q.beforeUpdate, ...subQuery.q.beforeCreate] : subQuery.q.beforeUpdate || subQuery.q.beforeCreate : subQuery.q.beforeCreate : subQuery.q.type === "delete" ? subQuery.q.beforeDelete : void 0 : void 0;
+  const { beforeSet } = subQuery.q;
+  beforeAction = beforeAction && beforeSet ? [...beforeAction, ...beforeSet] : beforeSet ? [...beforeSet] : beforeAction;
+  if (beforeAction) {
+    const newSet = new Set(mainQuery.q.beforeSet);
+    const filteredHooks = [];
+    for (const hook of beforeAction) {
+      if (!newSet.has(hook)) {
+        newSet.add(hook);
+        filteredHooks.push(hook);
+      }
+    }
+    mainQuery.q.beforeSet = newSet;
+    beforeAction = filteredHooks;
+    if (beforeAction.length) {
+      pushQueryArrayImmutable(
+        mainQuery,
+        "before",
+        beforeAction.map((fn) => () => fn(subQuery))
+      );
+    }
+  }
+  return subQuery;
+};
+setPrepareSubQueryForSql(prepareSubQueryForSql);
+setRawSqlPrepareSubQueryForSql(prepareSubQueryForSql);
+
 const addWithParsers = (w, parsers) => {
   for (const key in w.shape) {
     const { _parse } = w.shape[key];
@@ -6960,9 +6991,11 @@ const getShouldWrapMainQueryInCte = (ctx, q, type, isSubSql) => {
 const wrapMainQueryInCte = (ctx, q, isSubSql) => {
   let as;
   if (!isSubSql && !ctx.cteName) {
-    as = pqb.addTopCteSql(ctx, ctx.wrapAs, ctx.sql.join(" "));
+    as = internal.addTopCteSql(ctx, ctx.wrapAs, ctx.sql.join(" "));
   }
-  q.appendQueries?.forEach((query) => pqb.addTopCte("after", ctx, query));
+  q.appendQueries?.forEach(
+    (query) => internal.addTopCte("after", ctx, query, query.q.type)
+  );
   if (!isSubSql && !ctx.cteName) {
     const addNull = ctx.topCtx.cteHooks?.hasSelect;
     ctx.sql = [`SELECT *${addNull ? ", NULL" : ""} FROM ${as}`];
@@ -6982,9 +7015,6 @@ const makeSql = (ctx, type, isSubSql, runAfterQuery) => {
     runAfterQuery
   };
 };
-const quoteSchemaAndTable = (schema, table) => {
-  return schema ? `"${schema}"."${table}"` : `"${table}"`;
-};
 const requireTableOrStringFrom = (query) => {
   const table = query.table || (typeof query.q.from === "string" ? query.q.from : void 0);
   if (!table) {
@@ -7316,7 +7346,7 @@ const _joinLateral = (self, type, joinQuery, as, innerJoinLateral) => {
       existingValue.q.q.select = [
         {
           selectAs: {
-            ...(existingValue.q.q.select?.[0]).selectAs,
+            ...existingValue.q.q.select[0].selectAs,
             [joinAs]: joinValueSelect
           }
         }
@@ -8056,17 +8086,6 @@ const pushQueryOrOn = (q, joinFrom, joinTo, ...on) => {
     makeOnItem(joinFrom, joinTo, on)
   ]);
 };
-const addQueryOn = (query, joinFrom, joinTo, ...args) => {
-  const cloned = _clone(query);
-  const { q } = cloned;
-  setObjectValueImmutable(
-    q,
-    "joinedShapes",
-    joinFrom.q.as || joinFrom.table,
-    joinFrom.q.shape
-  );
-  return pushQueryOn(cloned, joinFrom, joinTo, ...args);
-};
 const _queryJoinOn = (q, args) => {
   return pushQueryOn(
     q,
@@ -8133,11 +8152,12 @@ class OnMethods {
   }
 }
 
-const _addToHookSelect = (query, selects) => {
+const _addToHookSelect = (query, selects, notLoaded) => {
   const { q } = query;
   const map = q.hookSelect = new Map(q.hookSelect);
   for (const key of selects) {
-    map.set(key, { select: key });
+    const item = map.get(key) || { select: key };
+    map.set(key, notLoaded ? { ...item, notLoaded } : item);
   }
 };
 const _addToHookSelectWithTable = (query, selects, table) => {
@@ -8148,6 +8168,10 @@ const _addToHookSelectWithTable = (query, selects, table) => {
   }
 };
 
+const setSelectRelation = (q) => {
+  q.selectRelation = true;
+};
+
 const addParserForRawExpression = (q, key, raw) => {
   if (raw.result.value) addColumnParserToQuery(q.q, key, raw.result.value);
 };
@@ -8406,7 +8430,8 @@ const processSelectArg = (q, as, arg, columnAs) => {
         if (isRelationQuery(value) && // `subQuery = 1` case is when callback returns the same query as it gets,
         // for example `q => q.get('name')`.
         value.q.subQuery !== 1) {
-          query.q.selectRelation = joinQuery = true;
+          joinQuery = true;
+          setSelectRelation(query.q);
           value = value.joinQuery(value, q);
           let subQuery;
           const { returnType, innerJoinLateral } = value.q;
@@ -8590,48 +8615,198 @@ const getShapeFromSelect = (q, isSubQuery) => {
       }
     }
   }
-  return result;
-};
-const addColumnToShapeFromSelect = (q, arg, shape, query, result, isSubQuery, key) => {
-  const index = arg.indexOf(".");
-  if (index !== -1) {
-    const as = q.q.as || q.table;
-    const table = getFullColumnTable(q, arg, index, as);
-    const column = arg.slice(index + 1);
-    if (table === as) {
-      result[key || column] = shape[column];
-    } else {
-      const it = query.joinedShapes?.[table]?.[column];
-      if (it)
-        result[key || column] = mapSubSelectColumn(
-          it,
-          isSubQuery
-        );
-    }
-  } else if (arg === "*") {
-    for (const key2 in shape) {
-      if (!shape[key2].data.explicitSelect) {
-        result[key2] = mapSubSelectColumn(
-          shape[key2],
-          isSubQuery
-        );
-      }
-    }
-  } else {
-    result[key || arg] = mapSubSelectColumn(
-      shape[arg],
-      isSubQuery
+  return result;
+};
+const addColumnToShapeFromSelect = (q, arg, shape, query, result, isSubQuery, key) => {
+  const index = arg.indexOf(".");
+  if (index !== -1) {
+    const as = q.q.as || q.table;
+    const table = getFullColumnTable(q, arg, index, as);
+    const column = arg.slice(index + 1);
+    if (table === as) {
+      result[key || column] = shape[column];
+    } else {
+      const it = query.joinedShapes?.[table]?.[column];
+      if (it)
+        result[key || column] = mapSubSelectColumn(
+          it,
+          isSubQuery
+        );
+    }
+  } else if (arg === "*") {
+    for (const key2 in shape) {
+      if (!shape[key2].data.explicitSelect) {
+        result[key2] = mapSubSelectColumn(
+          shape[key2],
+          isSubQuery
+        );
+      }
+    }
+  } else {
+    result[key || arg] = mapSubSelectColumn(
+      shape[arg],
+      isSubQuery
+    );
+  }
+};
+const mapSubSelectColumn = (column, isSubQuery) => {
+  if (!isSubQuery || !column || !column.data.name && !column.data.explicitSelect) {
+    return column;
+  }
+  const cloned = Object.create(column);
+  cloned.data = { ...column.data, name: void 0, explicitSelect: void 0 };
+  return cloned;
+};
+
+const _queryUnion = (base, args, k, p, m) => {
+  const query = base.baseQuery.clone();
+  const u = args.map(
+    (a) => ({
+      a: prepareSubQueryForSql(
+        base,
+        typeof a === "function" ? a(query) : a
+      ),
+      k,
+      m
+    })
+  );
+  const { q } = query;
+  const baseQ = base.q;
+  q.union = baseQ.union ? {
+    ...baseQ.union,
+    u: [...baseQ.union.u, ...u]
+  } : {
+    b: base,
+    u,
+    p
+  };
+  return query;
+};
+class Union {
+  /**
+   * Creates a union query, takes one or more queries or SQL expressions.
+   *
+   * ```ts
+   * import { sql } from './baseTable';
+   *
+   * // The first query of the union
+   * db.one
+   *   .select('id', 'name')
+   *   // add two more queries to the union
+   *   .union(
+   *     db.two.select('id', 'name'),
+   *     (q = sql`SELECT id, name FROM "thirdTable"`),
+   *   )
+   *   // sub-sequent `union` is equivalent to passing multiple queries into a single `union`
+   *   .union(db.three.select('id', 'name'));
+   * ```
+   *
+   * `order`, `limit`, `offset` are special, it matters if you place them **before** or **after** the `union`, it also have a meaning to place them before and after.
+   *
+   * ```ts
+   * // order, limit, offset are applied ONLY to 'one'
+   * db.one
+   *   .order('x')
+   *   .limit(1)
+   *   .offset(1)
+   *   // 'two' also has order, limit, and offset
+   *   .unionAll(db.two.order('y').limit(2).offset(2))
+   *   // sets order, limit, offset for all records
+   *   .order('z')
+   *   .limit(3)
+   *   .offset(3);
+   * ```
+   *
+   * Equivalent SQL:
+   *
+   * ```sql
+   * -- both union parts have their own order, limit, offset
+   * ( SELECT * FROM one ORDER x ASC LIMIT 1 OFFSET 1 )
+   * UNION ALL
+   * ( SELECT * FROM two ORDER y ASC LIMIT 2 OFFSET 2 )
+   * -- order, limit, offset of the whole query
+   * ORDER BY z ASC LIMIT 3 OFFSET 3
+   * ```
+   *
+   * All the listed methods have the same signature, they are only different by SQL keyword:
+   *
+   * - `union` - union of all queries, performs deduplication
+   * - `unionAll` - `union` that allows duplicated rows
+   * - `intersect` - get only rows that are present in all queries
+   * - `intersectAll` - `intersect` that allows duplicated rows
+   * - `except` - get only rows that are in the first query but not in the second
+   * - `exceptAll` - `except` that allows duplicated rows
+   *
+   * @param args - array of queries or SQL expressions
+   */
+  union(...args) {
+    return _queryUnion(
+      _clone(this),
+      args,
+      "UNION"
+    );
+  }
+  /**
+   * Same as {@link union}, but allows duplicated rows.
+   *
+   * @param args - array of queries or SQL expressions
+   */
+  unionAll(...args) {
+    return _queryUnion(
+      _clone(this),
+      args,
+      "UNION ALL"
+    );
+  }
+  /**
+   * Same as {@link union}, but uses a `INTERSECT` SQL keyword instead
+   *
+   * @param args - array of queries or SQL expressions
+   */
+  intersect(...args) {
+    return _queryUnion(
+      _clone(this),
+      args,
+      "INTERSECT"
+    );
+  }
+  /**
+   * Same as {@link intersect}, but allows duplicated rows.
+   *
+   * @param args - array of queries or SQL expressions
+   */
+  intersectAll(...args) {
+    return _queryUnion(
+      _clone(this),
+      args,
+      "INTERSECT ALL"
     );
   }
-};
-const mapSubSelectColumn = (column, isSubQuery) => {
-  if (!isSubQuery || !column || !column.data.name && !column.data.explicitSelect) {
-    return column;
+  /**
+   * Same as {@link union}, but uses an `EXCEPT` SQL keyword instead
+   *
+   * @param args - array of queries or SQL expressions
+   */
+  except(...args) {
+    return _queryUnion(
+      _clone(this),
+      args,
+      "EXCEPT"
+    );
   }
-  const cloned = Object.create(column);
-  cloned.data = { ...column.data, name: void 0, explicitSelect: void 0 };
-  return cloned;
-};
+  /**
+   * Same as {@link except}, but allows duplicated rows.
+   *
+   * @param args - array of queries or SQL expressions
+   */
+  exceptAll(...args) {
+    return _queryUnion(
+      _clone(this),
+      args,
+      "EXCEPT ALL"
+    );
+  }
+}
 
 const _addCte = (query, item) => pushOrNewArrayToObjectImmutable(query.q, "with", item);
 const _prependWith = (q, name, queryArg) => _with(q, name, queryArg, void 0, true);
@@ -8742,9 +8917,6 @@ const columnToSql = (ctx, data, shape, column, quotedAs, select) => {
       select
     );
   }
-  if (!select && data.joinedShapes?.[column]) {
-    return `"${column}"."${column}"`;
-  }
   return simpleColumnToSQL(ctx, column, shape[column], quotedAs);
 };
 const maybeSelectedColumnToSql = (ctx, data, column, quotedAs) => {
@@ -9082,97 +9254,285 @@ const _getSelectableColumn = (q, arg) => {
       }
     }
   }
-  return type;
+  return type;
+};
+const _get = (query, returnType, arg) => {
+  const q = query.q;
+  if (q.returning) q.returning = void 0;
+  q.returnType = returnType;
+  let type;
+  if (typeof arg === "string") {
+    const joinedAs = q.valuesJoinedAs?.[arg];
+    type = joinedAs ? q.joinedShapes?.[joinedAs]?.value : _getSelectableColumn(query, arg);
+    q.getColumn = type;
+    const selected = setParserForSelectedString(
+      query,
+      joinedAs ? joinedAs + "." + arg : arg,
+      getQueryAs(query),
+      getValueKey
+    );
+    q.select = selected ? [q.expr = new SelectItemExpression(query, selected, type)] : void 0;
+  } else {
+    type = arg.result.value;
+    q.getColumn = type;
+    addParserForRawExpression(query, getValueKey, arg);
+    q.select = [q.expr = arg];
+  }
+  return setQueryOperators(
+    query,
+    type?.operators || Operators.any
+  );
+};
+function _queryGet(self, arg) {
+  return _get(self, "valueOrThrow", arg);
+}
+function _queryGetOptional(self, arg) {
+  return _get(self, "value", arg);
+}
+
+class RowToJsonExpression extends Expression {
+  constructor(from, one, coalesce) {
+    super();
+    this.from = from;
+    this.one = one;
+    this.coalesce = coalesce;
+    this.result = { value: UnknownColumn.instance };
+    this.q = { expr: this };
+  }
+  makeSQL(ctx) {
+    const q = this.from;
+    const aliases = [];
+    const jsonList = {};
+    const select = selectToSql(
+      ctx,
+      q,
+      q.q,
+      `"${getQueryAs(q)}"`,
+      q.q.hookSelect,
+      void 0,
+      aliases,
+      jsonList
+    );
+    q.q.selectCache = { sql: select, aliases };
+    let rowToJson;
+    if (Object.values(jsonList).some((x) => x?.data.jsonCast)) {
+      rowToJson = `json_build_object(${Object.entries(jsonList).map(
+        ([key, column]) => `'${key}', t."${key}"${column?.data.jsonCast ? `::${column.data.jsonCast}` : ""}`
+      ).join(", ")})`;
+    } else {
+      rowToJson = "row_to_json(t.*)";
+    }
+    return this.one ? rowToJson : this.coalesce !== false ? `COALESCE(json_agg(${rowToJson}), '[]')` : `json_agg(${rowToJson})`;
+  }
+}
+function queryJson(self, coalesce) {
+  const inner = self.clone();
+  const q = queryWrap(inner, cloneQueryBaseUnscoped(inner));
+  _queryGetOptional(
+    q,
+    new RowToJsonExpression(
+      inner,
+      queryTypeWithLimitOne[self.q.returnType],
+      coalesce
+    )
+  );
+  q.q.returnsOne = true;
+  return q;
+}
+
+const moveQueryToCte = (ctx, query, type, dontAddTableHook) => {
+  const { returnType } = query.q;
+  let valueAs;
+  if (returnType === "value" || returnType === "valueOrThrow" || returnType === "pluck") {
+    const first = query.q.select[0];
+    if (first instanceof SelectItemExpression && typeof first.item === "string") {
+      valueAs = first.item;
+    } else {
+      query = _clone(query);
+      query.q.returnType = "one";
+      query.q.select = [{ selectAs: { value: query.q.select[0] } }];
+      valueAs = "value";
+    }
+  }
+  const as = addTopCte("before", ctx, query, type, void 0, dontAddTableHook);
+  const makeSelectList = (isSubSql) => {
+    const list = [];
+    let selectedCount = 0;
+    if (valueAs) {
+      selectedCount = 1;
+      list.push(`"${as}"."${valueAs}"`);
+    } else if (returnType !== "void") {
+      const shape = getShapeFromSelect(query, true);
+      const keys = Object.keys(shape);
+      selectedCount = keys.length;
+      list.push(...keys.map((key) => `"${as}"."${key}"`));
+    }
+    if (!isSubSql && ctx.topCtx.cteHooks?.hasSelect) {
+      list.push("NULL::json");
+      ctx.selectedCount = selectedCount;
+    }
+    return list;
+  };
+  return {
+    as,
+    makeSelectList
+  };
+};
+const moveMutativeQueryToCteBase = (toSql, ctx, query, type = query.q.type) => {
+  if (!query.q.type) {
+    const as2 = getQueryAs(query);
+    return {
+      as: as2,
+      makeSql: () => getSqlText(toSql(query, query.q.type, ctx, true))
+    };
+  }
+  const { as, makeSelectList } = moveQueryToCte(ctx, query, type);
+  return {
+    as,
+    // need to be called lazily for the upsert case because `ctx.cteHooks?.hasSelect` can change after the first query
+    makeSql(isSubSql) {
+      return "SELECT " + makeSelectList(isSubSql) + ` FROM "${as}"`;
+    }
+  };
+};
+
+const addTableHook = (ctx, q, data, select, hookPurpose, dontAddTableHook) => {
+  var _a, _b;
+  if (data.ensureCount !== void 0 && ctx.cteName) {
+    const cteHooks = setCteHooks(ctx, true);
+    (cteHooks.ensureCount ?? (cteHooks.ensureCount = {}))[ctx.cteName] = { count: data.ensureCount };
+  }
+  const afterCreate = data.afterCreate;
+  const afterUpdate = data.afterUpdate;
+  const afterSave = data.afterSave;
+  const afterDelete = data.afterDelete;
+  const afterCreateCommit = data.afterCreateCommit;
+  const afterUpdateCommit = data.afterUpdateCommit;
+  const afterSaveCommit = data.afterSaveCommit;
+  const afterDeleteCommit = data.afterDeleteCommit;
+  const throwOnNotFound = (
+    // Assuming that Create always returns a record, though needs to be cautions with onConflictDoNothing
+    hookPurpose !== "Create" && (data.returnType === "oneOrThrow" || data.returnType === "valueOrThrow")
+  );
+  const hasAfterHook = afterCreate || afterUpdate || afterSave || afterDelete || afterCreateCommit || afterUpdateCommit || afterSaveCommit || afterDeleteCommit;
+  if (!select && !hasAfterHook && !throwOnNotFound) {
+    return;
+  }
+  const tableHook = {
+    hookPurpose,
+    select,
+    afterCreate,
+    afterUpdate,
+    afterSave,
+    afterDelete,
+    afterCreateCommit,
+    afterUpdateCommit,
+    afterSaveCommit,
+    afterDeleteCommit
+  };
+  if (ctx.cteName && !dontAddTableHook) {
+    if (tableHook && (hasAfterHook || throwOnNotFound)) {
+      const shape = {};
+      if (tableHook.select) {
+        for (const key of tableHook.select.keys()) {
+          shape[key] = q.shape[key];
+        }
+      }
+      const item = {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        table: q.table,
+        shape,
+        tableHook,
+        throwOnNotFound
+      };
+      const hasSelect = throwOnNotFound || !!tableHook.select;
+      const cteHooks = setCteHooks(ctx, hasSelect);
+      (_a = cteHooks.tableHooks ?? (cteHooks.tableHooks = {}))[_b = ctx.cteName] ?? (_a[_b] = item);
+    }
+  } else {
+    ctx.topCtx.tableHook = tableHook;
+  }
 };
-const _get = (query, returnType, arg) => {
-  const q = query.q;
-  if (q.returning) q.returning = void 0;
-  q.returnType = returnType;
-  let type;
-  if (typeof arg === "string") {
-    const joinedAs = q.valuesJoinedAs?.[arg];
-    type = joinedAs ? q.joinedShapes?.[joinedAs]?.value : _getSelectableColumn(query, arg);
-    q.getColumn = type;
-    const selected = setParserForSelectedString(
-      query,
-      joinedAs ? joinedAs + "." + arg : arg,
-      getQueryAs(query),
-      getValueKey
-    );
-    q.select = selected ? [q.expr = new SelectItemExpression(query, selected, type)] : void 0;
+const setCteHooks = (ctx, hasSelect) => {
+  if (hasSelect && ctx.topCtx.selectList && ctx.topCtx === ctx.topCtx.topCtx && !ctx.topCtx.cteHookTopNullSelectAppended) {
+    ctx.topCtx.selectList.push("NULL");
+    ctx.topCtx.cteHookTopNullSelectAppended = true;
+  }
+  if (ctx.topCtx.cteHooks) {
+    if (hasSelect) ctx.topCtx.cteHooks.hasSelect = true;
+    return ctx.topCtx.cteHooks;
   } else {
-    type = arg.result.value;
-    q.getColumn = type;
-    addParserForRawExpression(query, getValueKey, arg);
-    q.select = [q.expr = arg];
+    return ctx.topCtx.cteHooks = {
+      hasSelect
+    };
   }
-  return setQueryOperators(
-    query,
-    type?.operators || Operators.any
-  );
 };
-function _queryGet(self, arg) {
-  return _get(self, "valueOrThrow", arg);
-}
-function _queryGetOptional(self, arg) {
-  return _get(self, "value", arg);
-}
+const ensureCTECount = (ctx, cteName, countItem) => {
+  var _a;
+  ((_a = setCteHooks(ctx, true)).ensureCount ?? (_a.ensureCount = {}))[cteName] = countItem;
+};
 
-class RowToJsonExpression extends Expression {
-  constructor(from, one, coalesce) {
-    super();
-    this.from = from;
-    this.one = one;
-    this.coalesce = coalesce;
-    this.result = { value: UnknownColumn.instance };
-    this.q = { expr: this };
+const newMutativeQueriesSelectRelationsSqlState = (query) => query.q.selectRelation && {
+  query
+};
+const setMutativeQueriesSelectRelationsSqlState = (d, as, rel) => {
+  (d.value ?? (d.value = {}))[as] = rel;
+};
+const handleInsertAndUpdateSelectRelationsSqlState = (ctx, state) => {
+  if (state) {
+    ctx.topCtx.mutativeQueriesSelectRelationsSqlState = state;
   }
-  makeSQL(ctx) {
-    const q = this.from;
-    const aliases = [];
-    const jsonList = {};
-    const select = selectToSql(
-      ctx,
-      q,
-      q.q,
-      `"${getQueryAs(q)}"`,
-      q.q.hookSelect,
-      void 0,
-      aliases,
-      jsonList
-    );
-    q.q.selectCache = { sql: select, aliases };
-    let rowToJson;
-    if (Object.values(jsonList).some((x) => x?.data.jsonCast)) {
-      rowToJson = `json_build_object(${Object.entries(jsonList).map(
-        ([key, column]) => `'${key}', t."${key}"${column?.data.jsonCast ? `::${column.data.jsonCast}` : ""}`
-      ).join(", ")})`;
-    } else {
-      rowToJson = "row_to_json(t.*)";
+};
+const handleDeleteSelectRelationsSqlState = (ctx, query, relationSelectState, returning) => {
+  const selectRelations = relationSelectState?.value;
+  if (!selectRelations) return;
+  const selectPrimaryKeysQuery = prepareSubQueryForSql(query, _clone(query));
+  const primaryKeys = requirePrimaryKeys(
+    query,
+    "primary keys are required for selecting relation in delete"
+  );
+  _addToHookSelect(selectPrimaryKeysQuery, primaryKeys, true);
+  const { as: cteAs } = moveQueryToCte(
+    ctx,
+    selectPrimaryKeysQuery,
+    void 0,
+    true
+  );
+  const relKeys = Object.keys(selectRelations);
+  ctx.selectedCount = (returning ? ctx.selectedCount : 0) + relKeys.length;
+  const hookSelect = selectPrimaryKeysQuery.q.hookSelect;
+  const join = {
+    type: "JOIN",
+    args: {
+      w: cteAs,
+      a: [
+        Object.fromEntries(
+          primaryKeys.map((key) => {
+            const selected = hookSelect.get(key);
+            return [
+              cteAs + "." + (selected.as || selected.select),
+              key
+            ];
+          })
+        )
+      ]
+    }
+  };
+  for (const relKey in selectRelations) {
+    const rel = selectRelations[relKey];
+    if (rel.q.returnType === "oneOrThrow" || rel.q.returnType === "valueOrThrow") {
+      ensureCTECount(ctx, cteAs, { jsonNotNull: relKey });
     }
-    return this.one ? rowToJson : this.coalesce !== false ? `COALESCE(json_agg(${rowToJson}), '[]')` : `json_agg(${rowToJson})`;
   }
-}
-function queryJson(self, coalesce) {
-  const inner = self.clone();
-  const q = queryWrap(inner, cloneQueryBaseUnscoped(inner));
-  _queryGetOptional(
-    q,
-    new RowToJsonExpression(
-      inner,
-      queryTypeWithLimitOne[self.q.returnType],
-      coalesce
-    )
-  );
-  q.q.returnsOne = true;
-  return q;
-}
-
-const newDelayedRelationSelect = (query) => ({
-  query
-});
-const setDelayedRelation = (d, as, value) => {
-  (d.value ?? (d.value = {}))[as] = value;
+  return {
+    join,
+    joinedShape: cteAs,
+    movedWhereToCte: true,
+    addReturning: relKeys.map((key) => `${cteAs}."${key}"`).join(", ")
+  };
+};
+const setMutativeQueriesSelectRelationsStateOnSql = (ctx, sql) => {
+  sql.mutativeQueriesSelectRelationsState = ctx.topCtx.mutativeQueriesSelectRelationsSqlState;
 };
 
 const setSqlCtxSelectList = (ctx, table, query, quotedAs, isSubSql, aliases) => {
@@ -9271,7 +9631,11 @@ const selectToSqlList = (ctx, table, query, quotedAs, hookSelect = query.hookSel
                 }
                 aliases?.push(as);
               } else if (delayedRelationSelect && isRelationQuery(value)) {
-                setDelayedRelation(delayedRelationSelect, as, value);
+                setMutativeQueriesSelectRelationsSqlState(
+                  delayedRelationSelect,
+                  as,
+                  value
+                );
               } else {
                 pushSubQuerySql(ctx, query, value, as, list, quotedAs, aliases);
                 if (jsonList) {
@@ -9403,13 +9767,13 @@ const internalSelectAllSql = (ctx, query, quotedAs, jsonList) => {
   }
   let columnsCount;
   if (query.shape !== anyShape) {
-    let columnsCount2 = 0;
+    columnsCount = 0;
     for (const key in query.shape) {
       if (!query.shape[key].data.explicitSelect) {
-        columnsCount2++;
+        columnsCount++;
       }
     }
-    ctx.selectedCount += columnsCount2;
+    ctx.selectedCount += columnsCount;
   }
   return selectAllSql(query, quotedAs, columnsCount);
 };
@@ -9780,134 +10144,6 @@ const pushIn = (ctx, query, ands, quotedAs, arg) => {
 
 const MAX_BINDING_PARAMS = 65536;
 
-const addTableHook = (ctx, q, data, select, hookPurpose) => {
-  var _a, _b;
-  if (data.ensureCount !== void 0 && ctx.cteName) {
-    const cteHooks = setCteHooks(ctx, true);
-    (cteHooks.ensureCount ?? (cteHooks.ensureCount = {}))[ctx.cteName] = data.ensureCount;
-  }
-  const afterCreate = data.afterCreate;
-  const afterUpdate = data.afterUpdate;
-  const afterSave = data.afterSave;
-  const afterDelete = data.afterDelete;
-  const afterCreateCommit = data.afterCreateCommit;
-  const afterUpdateCommit = data.afterUpdateCommit;
-  const afterSaveCommit = data.afterSaveCommit;
-  const afterDeleteCommit = data.afterDeleteCommit;
-  const throwOnNotFound = (
-    // Assuming that Create always returns a record, though needs to be cautions with onConflictDoNothing
-    hookPurpose !== "Create" && (data.returnType === "oneOrThrow" || data.returnType === "valueOrThrow")
-  );
-  const hasAfterHook = afterCreate || afterUpdate || afterSave || afterDelete || afterCreateCommit || afterUpdateCommit || afterSaveCommit || afterDeleteCommit;
-  if (!select && !hasAfterHook && !throwOnNotFound) {
-    return;
-  }
-  const tableHook = {
-    hookPurpose,
-    select,
-    afterCreate,
-    afterUpdate,
-    afterSave,
-    afterDelete,
-    afterCreateCommit,
-    afterUpdateCommit,
-    afterSaveCommit,
-    afterDeleteCommit
-  };
-  if (ctx.cteName) {
-    if (tableHook && (hasAfterHook || throwOnNotFound)) {
-      const shape = {};
-      if (tableHook.select) {
-        for (const key of tableHook.select.keys()) {
-          shape[key] = q.shape[key];
-        }
-      }
-      const item = {
-        table: q.table,
-        shape,
-        tableHook,
-        throwOnNotFound
-      };
-      const hasSelect = throwOnNotFound || !!tableHook.select;
-      const cteHooks = setCteHooks(ctx, hasSelect);
-      (_a = cteHooks.tableHooks)[_b = ctx.cteName] ?? (_a[_b] = item);
-    }
-  } else {
-    ctx.topCtx.tableHook = tableHook;
-  }
-};
-const setCteHooks = (ctx, hasSelect) => {
-  if (hasSelect && ctx.topCtx.selectList && ctx.topCtx === ctx.topCtx.topCtx && !ctx.topCtx.cteHookTopNullSelectAppended) {
-    ctx.topCtx.selectList.push("NULL");
-    ctx.topCtx.cteHookTopNullSelectAppended = true;
-  }
-  if (ctx.topCtx.cteHooks) {
-    if (hasSelect) ctx.topCtx.cteHooks.hasSelect = true;
-    return ctx.topCtx.cteHooks;
-  } else {
-    return ctx.topCtx.cteHooks = {
-      hasSelect,
-      tableHooks: {}
-    };
-  }
-};
-
-const moveQueryToCte = (ctx, query, type = query.q.type) => {
-  const { returnType } = query.q;
-  let valueAs;
-  if (returnType === "value" || returnType === "valueOrThrow" || returnType === "pluck") {
-    const first = query.q.select[0];
-    if (first instanceof SelectItemExpression && typeof first.item === "string") {
-      valueAs = first.item;
-    } else {
-      query = _clone(query);
-      query.q.returnType = "one";
-      query.q.select = [{ selectAs: { value: query.q.select[0] } }];
-      valueAs = "value";
-    }
-  }
-  const as = addTopCte("before", ctx, query, void 0, type);
-  const makeSelectList = (isSubSql) => {
-    const list = [];
-    let selectedCount = 0;
-    if (valueAs) {
-      selectedCount = 1;
-      list.push(`"${as}"."${valueAs}"`);
-    } else if (returnType !== "void") {
-      const shape = getShapeFromSelect(query, true);
-      const keys = Object.keys(shape);
-      selectedCount = keys.length;
-      list.push(...keys.map((key) => `"${as}"."${key}"`));
-    }
-    if (!isSubSql && ctx.topCtx.cteHooks?.hasSelect) {
-      list.push("NULL::json");
-      ctx.selectedCount = selectedCount;
-    }
-    return list;
-  };
-  return {
-    as,
-    makeSelectList
-  };
-};
-const moveMutativeQueryToCteBase = (toSql, ctx, query, type = query.q.type) => {
-  if (!query.q.type) {
-    const as2 = getQueryAs(query);
-    return {
-      as: as2,
-      makeSql: () => getSqlText(toSql(query, query.q.type, ctx, true))
-    };
-  }
-  const { as, makeSelectList } = moveQueryToCte(ctx, query, type);
-  return {
-    as,
-    // need to be called lazily for the upsert case because `ctx.cteHooks?.hasSelect` can change after the first query
-    makeSql(isSubSql) {
-      return "SELECT " + makeSelectList(isSubSql) + ` FROM "${as}"`;
-    }
-  };
-};
-
 const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
   let { columns } = query;
   const { shape, hookCreateSet } = query;
@@ -9976,7 +10212,7 @@ const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
   if (upsert || insertFrom && !isRelationQuery(q) || hasOnConflictWhere) {
     pushWhereStatementSql(ctx, q, query, quotedAs);
   }
-  sqlState.delayedRelationSelect = q.q.selectRelation ? newDelayedRelationSelect(q) : void 0;
+  sqlState.relationSelectState = newMutativeQueriesSelectRelationsSqlState(q);
   sqlState.returningPos = ctx.sql.length;
   let insertManyFromValuesAs;
   if (insertFrom) {
@@ -10000,7 +10236,11 @@ const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
       }
       ctx.sql[1] = moveMutativeQueryToCte(ctx, q2);
     } else {
-      const { as, makeSelectList } = moveQueryToCte(ctx, insertFrom);
+      const { as, makeSelectList } = moveQueryToCte(
+        ctx,
+        insertFrom,
+        insertFrom.q.type
+      );
       const selectList = makeSelectList(true);
       insertManyFromValuesAs = query.insertValuesAs;
       selectList.push(
@@ -10066,18 +10306,20 @@ const makeInsertSql = (ctx, q, query, quotedAs, isSubSql) => {
       }
       applySqlState(sqlState);
       batch.push(composeCteSingleSql(ctx));
-      if (sqlState.delayedRelationSelect) {
-        ctx.topCtx.delayedRelationSelect = sqlState.delayedRelationSelect;
-      }
+      handleInsertAndUpdateSelectRelationsSqlState(
+        ctx,
+        sqlState.relationSelectState
+      );
       return {
         batch
       };
     }
   }
   applySqlState(sqlState);
-  if (sqlState.delayedRelationSelect) {
-    ctx.topCtx.delayedRelationSelect = sqlState.delayedRelationSelect;
-  }
+  handleInsertAndUpdateSelectRelationsSqlState(
+    ctx,
+    sqlState.relationSelectState
+  );
   return {
     text: ctx.sql.join(" "),
     values: ctx.values
@@ -10164,7 +10406,7 @@ const applySqlState = (sqlState) => {
     sqlState.q,
     sqlState.query,
     sqlState.quotedAs,
-    sqlState.delayedRelationSelect,
+    sqlState.relationSelectState,
     "Create",
     void 0,
     sqlState.isSubSql || !!ctx.topCtx.cteHooks
@@ -10347,7 +10589,7 @@ const encodeValue = (ctx, values, QueryClass, value, quotedAs) => {
   }
   return value === void 0 ? "DEFAULT" : addValue(values, value);
 };
-const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookPurpose, addHookPurpose, isSubSql) => {
+const makeReturningSql = (ctx, q, data, quotedAs, relationSelectState, hookPurpose, addHookPurpose, isSubSql) => {
   const hookSelect = hookPurpose && data[`after${hookPurpose}Select`];
   const { select } = data;
   if (!q.q.hookSelect && !hookSelect?.size && !select?.length && !hookPurpose) {
@@ -10356,7 +10598,7 @@ const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookPur
     ctx.selectedCount = 1;
     return returnSqlOrNull(ctx, q, isSubSql);
   }
-  const otherCTEHookSelect = addHookPurpose && data[`after${addHookPurpose}Select`];
+  const otherCTEHookSelect = addHookPurpose;
   let tempSelect;
   if (q.q.hookSelect || hookSelect || otherCTEHookSelect || q.q.selectRelation) {
     tempSelect = new Map(q.q.hookSelect);
@@ -10367,14 +10609,7 @@ const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookPur
         }
       }
     }
-    if (otherCTEHookSelect) {
-      for (const column of otherCTEHookSelect) {
-        if (!tempSelect.has(column)) {
-          tempSelect.set(column, { select: column });
-        }
-      }
-    }
-    if (q.q.selectRelation) {
+    if (q.q.selectRelation && hookPurpose !== "Delete") {
       for (const column of getPrimaryKeys(q)) {
         if (!tempSelect.has(column)) {
           tempSelect.set(column, { select: column });
@@ -10393,7 +10628,7 @@ const makeReturningSql = (ctx, q, data, quotedAs, delayedRelationSelect, hookPur
       isSubSql,
       void 0,
       void 0,
-      delayedRelationSelect
+      relationSelectState
     );
   }
   addTableHook(ctx, q, data, tempSelect, hookPurpose);
@@ -10437,7 +10672,7 @@ const pushUpdateSql = (ctx, query, q, quotedAs, isSubSql) => {
   const hookSet = q.hookUpdateSet ? Object.fromEntries(
     q.hookUpdateSet.flatMap((item) => Object.entries(item))
   ) : emptyObject;
-  const delayedRelationSelect = q.selectRelation ? newDelayedRelationSelect(query) : void 0;
+  const relationSelectState = newMutativeQueriesSelectRelationsSqlState(query);
   const usedSetKeys = /* @__PURE__ */ new Set();
   if (q.hookUpdateSet) {
     applySet(ctx, query, set, hookSet, emptyObject, usedSetKeys, quotedAs);
@@ -10469,7 +10704,7 @@ const pushUpdateSql = (ctx, query, q, quotedAs, isSubSql) => {
       from,
       isSubSql,
       updateManyValuesSql,
-      delayedRelationSelect
+      relationSelectState
     );
   } else {
     ctx.sql.push(`UPDATE ${from}`);
@@ -10493,16 +10728,14 @@ const pushUpdateSql = (ctx, query, q, quotedAs, isSubSql) => {
       q,
       quotedAs,
       "RETURNING",
-      delayedRelationSelect,
+      relationSelectState,
       isSubSql
     );
   }
-  if (delayedRelationSelect) {
-    ctx.topCtx.delayedRelationSelect = delayedRelationSelect;
-  }
+  handleInsertAndUpdateSelectRelationsSqlState(ctx, relationSelectState);
   return makeSql(ctx, "update", isSubSql);
 };
-const pushSelectForEmptySet = (ctx, query, q, quotedAs, from, isSubSql, updateManyValuesSql, delayedRelationSelect) => {
+const pushSelectForEmptySet = (ctx, query, q, quotedAs, from, isSubSql, updateManyValuesSql, relationSelectState) => {
   if (!q.select) {
     q.select = countSelect;
   }
@@ -10512,7 +10745,7 @@ const pushSelectForEmptySet = (ctx, query, q, quotedAs, from, isSubSql, updateMa
     q,
     quotedAs,
     "SELECT",
-    delayedRelationSelect,
+    relationSelectState,
     isSubSql
   );
   let fromSql = `FROM ${from}`;
@@ -10524,15 +10757,9 @@ const pushSelectForEmptySet = (ctx, query, q, quotedAs, from, isSubSql, updateMa
   pushLimitSQL(ctx.sql, ctx.values, q);
 };
 const addUpdateManyCteForStrict = (ctx, updateMany) => {
-  var _a;
   const wrapAs = setFreeTopCteAs(ctx);
   ctx.wrapAs = wrapAs;
-  const cteHooks = (_a = ctx.topCtx).cteHooks ?? (_a.cteHooks = {
-    hasSelect: true,
-    tableHooks: {}
-  });
-  cteHooks.hasSelect = true;
-  (cteHooks.ensureCount ?? (cteHooks.ensureCount = {}))[wrapAs] = updateMany.data.length;
+  ensureCTECount(ctx, wrapAs, { count: updateMany.data.length });
 };
 const pushUpdateFromSql = (ctx, query, q, quotedAs, updateFrom) => {
   const { target, on } = processJoinItem(ctx, query, q, updateFrom, quotedAs);
@@ -10568,13 +10795,13 @@ const pushUpdateWhereSql = (ctx, query, q, quotedAs, fromWhereSql) => {
     ctx.sql.push("WHERE", whereSql);
   }
 };
-const pushUpdateReturning = (ctx, query, q, quotedAs, keyword, delayedRelationSelect, isSubSql) => {
+const pushUpdateReturning = (ctx, query, q, quotedAs, keyword, relationSelectState, isSubSql) => {
   const returning = makeReturningSql(
     ctx,
     query,
     q,
     quotedAs,
-    delayedRelationSelect,
+    relationSelectState,
     "Update",
     void 0,
     isSubSql
@@ -10700,12 +10927,41 @@ const pushDeleteSql = (ctx, query, q, quotedAs, isSubSql) => {
   if (q.as && query.table !== q.as) {
     ctx.sql.push(quotedAs);
   }
+  const relationSelectState = newMutativeQueriesSelectRelationsSqlState(query);
+  let returning = makeReturningSql(
+    ctx,
+    query,
+    q,
+    quotedAs,
+    relationSelectState,
+    "Delete",
+    void 0,
+    isSubSql
+  );
+  const selectRelations = handleDeleteSelectRelationsSqlState(
+    ctx,
+    query,
+    relationSelectState,
+    returning
+  );
+  let join = q.join;
+  if (selectRelations) {
+    returning = (returning ? returning + ", " : "") + selectRelations.addReturning;
+    join = join ? [...join, selectRelations.join] : [selectRelations.join];
+    q = {
+      ...q,
+      joinedShapes: {
+        ...q.joinedShapes,
+        [selectRelations.joinedShape]: anyShape
+      }
+    };
+  }
   let conditions;
-  if (q.join?.length) {
+  if (join?.length) {
     const targets = [];
     const ons = [];
-    const joinSet = q.join.length > 1 ? /* @__PURE__ */ new Set() : null;
-    for (const item of q.join) {
+    const joinSet = join.length > 1 ? /* @__PURE__ */ new Set() : null;
+    for (const item of join) {
       const lateral = "l" in item.args && item.args.l;
       if (lateral) {
         if (isRelationQuery(lateral)) {
@@ -10716,42 +10972,32 @@ const pushDeleteSql = (ctx, query, q, quotedAs, isSubSql) => {
           "Join lateral is not supported in delete"
         );
       }
-      const join = processJoinItem(ctx, query, q, item.args, quotedAs);
-      const key = `${join.target}${join.on}`;
+      const join2 = processJoinItem(ctx, query, q, item.args, quotedAs);
+      const key = `${join2.target}${join2.on}`;
       if (joinSet) {
         if (joinSet.has(key)) continue;
         joinSet.add(key);
       }
-      targets.push(join.target);
-      if (join.on) ons.push(join.on);
+      targets.push(join2.target);
+      if (join2.on) ons.push(join2.on);
     }
     if (targets.length) {
       ctx.sql.push(`USING ${targets.join(", ")}`);
     }
     conditions = ons.join(" AND ");
   }
-  pushWhereStatementSql(ctx, query, q, quotedAs);
+  if (!selectRelations?.movedWhereToCte) {
+    pushWhereStatementSql(ctx, query, q, quotedAs);
+  }
   if (conditions) {
-    if (q.and?.length || q.or?.length || q.scopes) {
+    if (!selectRelations?.movedWhereToCte && (q.and?.length || q.or?.length || q.scopes)) {
       ctx.sql.push("AND", conditions);
     } else {
       ctx.sql.push("WHERE", conditions);
     }
   }
-  const delayedRelationSelect = q.selectRelation ? newDelayedRelationSelect(query) : void 0;
-  const returning = makeReturningSql(
-    ctx,
-    query,
-    q,
-    quotedAs,
-    delayedRelationSelect,
-    "Delete",
-    void 0,
-    isSubSql
-  );
-  if (returning) ctx.sql.push("RETURNING", returning);
-  if (delayedRelationSelect) {
-    ctx.topCtx.delayedRelationSelect = delayedRelationSelect;
+  if (returning) {
+    ctx.sql.push("RETURNING", returning);
   }
   return makeSql(ctx, "delete", isSubSql);
 };
@@ -11011,7 +11257,19 @@ const pushForSql = (ctx, q, type, quotedAs) => {
   }
 };
 
-const toSql = (table, type, topCtx, isSubSql, cteName, calledByThen) => {
+const newToSqlCtx = (query) => {
+  const ctx = {
+    topCtx: void 0,
+    qb: query.qb,
+    q: query.q,
+    sql: [],
+    values: [],
+    selectedCount: 0
+  };
+  ctx.topCtx = ctx;
+  return ctx;
+};
+const toSql = (table, type, topCtx, isSubSql, cteName, calledByThen, dontAddTableHook) => {
   const query = table.q;
   const sql = [];
   const values = topCtx?.values || [];
@@ -11191,7 +11449,14 @@ const toSql = (table, type, topCtx, isSubSql, cteName, calledByThen) => {
     }
     pushLimitOffsetSql(ctx, query, fromQuery);
     pushForSql(ctx, query, type, quotedAs);
-    addTableHook(ctx, table, query, query.hookSelect);
+    addTableHook(
+      ctx,
+      table,
+      query,
+      query.hookSelect,
+      void 0,
+      dontAddTableHook
+    );
     if (selectSqlPos !== void 0 && ctx.selectList?.length) {
       sql[selectSqlPos] += " " + ctx.selectList.join(", ");
     }
@@ -11204,7 +11469,7 @@ const toSql = (table, type, topCtx, isSubSql, cteName, calledByThen) => {
   if (!ctx.cteName) {
     result.tableHook = ctx.topCtx.tableHook;
     if (!topCtx) {
-      result.delayedRelationSelect = ctx.topCtx.delayedRelationSelect;
+      setMutativeQueriesSelectRelationsStateOnSql(ctx, result);
     }
   }
   if (!isSubSql) {
@@ -11214,21 +11479,20 @@ const toSql = (table, type, topCtx, isSubSql, cteName, calledByThen) => {
         if (prependedSelectParenthesis) {
           result.text += ")";
         }
-        const keyValues = Object.entries(ctx.topCtx.cteHooks.tableHooks).map(
-          ([cteName2, data]) => `'${cteName2}', (SELECT json_agg(${makeRowToJson(
-            cteName2,
-            data.shape,
-            false,
-            true
-          )}) FROM "${cteName2}")`
-        );
-        if (ctx.topCtx.cteHooks.ensureCount) {
-          keyValues.push(
-            ...Object.entries(ctx.topCtx.cteHooks.ensureCount).map(
-              ([cteName2, count]) => `'#${cteName2}', CASE WHEN (SELECT count(*) FROM "${cteName2}") < ${count} THEN (SELECT 'not-found')::int END`
-            )
-          );
-        }
+        const { tableHooks, ensureCount } = ctx.topCtx.cteHooks;
+        const keyValues = [
+          ...tableHooks ? Object.entries(tableHooks).map(
+            ([cteName2, data]) => `'${cteName2}', (SELECT json_agg(${makeRowToJson(
+              cteName2,
+              data.shape,
+              false,
+              true
+            )}) FROM "${cteName2}")`
+          ) : internal.emptyArray,
+          ...ensureCount ? Object.entries(ensureCount).map(
+            ([cteName2, item]) => `'#${cteName2}', CASE WHEN ${"count" in item ? `(SELECT count(*) FROM "${cteName2}") < ${item.count}` : `(SELECT "${cteName2}"."${item.jsonNotNull}" FROM "${cteName2}") IS NULL`} THEN (SELECT 'not-found')::int END`
+          ) : internal.emptyArray
+        ];
         result.text += ` UNION ALL SELECT ${"NULL, ".repeat(
           ctx.selectedCount || 0
         )}json_build_object(${keyValues.join(", ")})`;
@@ -11261,13 +11525,13 @@ const ctesToSql = (ctx, ctes) => {
   for (const item of ctes) {
     const place = item.p ? "before" : "after";
     if (ctx !== ctx.topCtx && item.q?.q.type) {
-      addTopCte(place, ctx, item.q, item.n);
+      addTopCte(place, ctx, item.q, item.q.q.type, item.n);
     } else {
-      addTopCteInternal(place, ctx, item);
+      addTopCteInternal(place, ctx, item, item.q?.q.type);
     }
   }
 };
-const cteToSqlGiveAs = (ctx, item, type) => {
+const cteToSqlGiveAs = (ctx, item, type, dontAddTableHook) => {
   var _a;
   let inner;
   let as;
@@ -11284,13 +11548,7 @@ const cteToSqlGiveAs = (ctx, item, type) => {
   }
   if (item.q) {
     inner = getSqlText(
-      toSql(
-        item.q,
-        type === void 0 ? item.q.q.type : type,
-        ctx.topCtx,
-        true,
-        as
-      )
+      toSql(item.q, type, ctx.topCtx, true, as, void 0, dontAddTableHook)
     );
   } else {
     inner = item.s.toSQL(ctx.topCtx, `"${as}"`);
@@ -11301,7 +11559,7 @@ const cteToSqlGiveAs = (ctx, item, type) => {
     sql: `${o.recursive ? "RECURSIVE " : ""}"${as}"${o.columns ? `(${o.columns.map((x) => `"${x}"`).join(", ")})` : ""} AS ${o.materialized ? "MATERIALIZED " : o.notMaterialized ? "NOT MATERIALIZED " : ""}(${inner})`
   };
 };
-const cteToSql = (ctx, item, type) => cteToSqlGiveAs(ctx, item, type).sql;
+const cteToSql = (ctx, item, type, dontAddTableHook) => cteToSqlGiveAs(ctx, item, type, dontAddTableHook).sql;
 const setFreeTopCteAs = (ctx) => {
   var _a;
   const topCTE = (_a = ctx.topCtx).topCTE ?? (_a.topCTE = newTopCte(ctx));
@@ -11318,7 +11576,7 @@ const addTopCteSql = (ctx, as, sql) => {
   target.push(as + " AS (" + sql + ")");
   return as;
 };
-const addTopCte = (place, ctx, q, as, type) => {
+const addTopCte = (place, ctx, q, type, as, dontAddTableHook) => {
   var _a;
   const topCTE = (_a = ctx.topCtx).topCTE ?? (_a.topCTE = newTopCte(ctx));
   if (typeof as !== "string") {
@@ -11328,16 +11586,16 @@ const addTopCte = (place, ctx, q, as, type) => {
     }
     as = name;
   }
-  addTopCteInternal(place, ctx, { n: as, q }, type);
+  addTopCteInternal(place, ctx, { n: as, q }, type, dontAddTableHook);
   return as;
 };
-const addTopCteInternal = (place, ctx, item, type) => {
+const addTopCteInternal = (place, ctx, item, type, dontAddTableHook) => {
   var _a;
   const topCTE = (_a = ctx.topCtx).topCTE ?? (_a.topCTE = newTopCte(ctx));
   const target = place === "before" && topCTE.stack[topCTE.stack.length - 1] || (topCTE.append[topCTE.append.length] = []);
   const prepend = [];
   topCTE.stack.push(prepend);
-  const sql = cteToSql(ctx, item, type);
+  const sql = cteToSql(ctx, item, type, dontAddTableHook);
   target.push(...prepend, sql);
   topCTE.stack.pop();
 };
@@ -14134,11 +14392,11 @@ class QueryExpressions {
 }
 
 const _appendQuery = (main, append, asFn) => {
-  return pqb.pushQueryValueImmutable(
-    pqb.pushQueryValueImmutable(
+  return internal.pushQueryValueImmutable(
+    internal.pushQueryValueImmutable(
       main,
       "appendQueries",
-      pqb.prepareSubQueryForSql(main, append)
+      internal.prepareSubQueryForSql(main, append)
     ),
     "asFns",
     asFn
@@ -14196,54 +14454,6 @@ class MergeQueryMethods {
   }
 }
 
-class QueryScope {
-  /**
-   * See {@link QueryScope}
-   *
-   * Use the `scope` method to apply a pre-defined scope.
-   *
-   * ```ts
-   * // use the `active` scope that is defined in the table:
-   * await db.some.scope('active');
-   * ```
-   *
-   * @param scope - name of the scope to apply
-   */
-  scope(scope) {
-    const q = _clone(this);
-    if (!q.q.scopes?.[scope]) {
-      const s = q.internal.scopes[scope];
-      if (!s) throw new Error(`Scope ${scope} is not defined`);
-      setObjectValueImmutable(q.q, "scopes", scope, s);
-    }
-    return q;
-  }
-  /**
-   * See {@link QueryScope}
-   *
-   * Remove conditions that were added by the scope from the query.
-   *
-   * ```ts
-   * // SomeTable has a default scope, ignore it for this query:
-   * await db.some.unscope('default');
-   * ```
-   *
-   * @param scope - name of the scope to remove from the query
-   */
-  unscope(scope) {
-    const q = _clone(this);
-    if (q.q.scopes) {
-      q.q.scopes = { ...q.q.scopes };
-      delete q.q.scopes[scope];
-      for (const _ in q.q.scopes) {
-        return q;
-      }
-      delete q.q.scopes;
-    }
-    return q;
-  }
-}
-
 const DEFAULT_PRIVILEGE = {
   OBJECT_TYPES: [
     "TABLES",
@@ -14794,7 +15004,7 @@ class SoftDeleteMethods {
    * ```
    */
   includeDeleted() {
-    return this.unscope("nonDeleted");
+    return _unscope(_clone(this), "nonDeleted");
   }
   /**
    * `hardDelete` deletes records bypassing the `softDelete` behavior:
@@ -14804,7 +15014,7 @@ class SoftDeleteMethods {
    * ```
    */
   hardDelete(..._args) {
-    return _queryDelete(_clone(this).unscope("nonDeleted"));
+    return _queryDelete(_unscope(_clone(this), "nonDeleted"));
   }
 }
 
@@ -15562,108 +15772,6 @@ applyMixins(QueryMethods, [
   QueryWindow
 ]);
 
-const makeIndex = (columns, first, second) => {
-  if (typeof first === "string") {
-    const options = { ...second, name: first };
-    return {
-      index: { columns, options }
-    };
-  } else {
-    const options = first ?? {};
-    return {
-      index: { columns, options }
-    };
-  }
-};
-const tableDataMethods = {
-  primaryKey(columns, name) {
-    return { primaryKey: { columns, name } };
-  },
-  unique(columns, ...args) {
-    const [first, second] = args;
-    const input = makeIndex(columns, first, second);
-    input.index.options.unique = true;
-    return input;
-  },
-  index: makeIndex,
-  searchIndex(columns, ...args) {
-    var _a;
-    const [first, second] = args;
-    const input = makeIndex(columns, first, second);
-    (_a = input.index.options).using ?? (_a.using = "gin");
-    input.index.options.tsVector = true;
-    return input;
-  },
-  exclude(columns, ...args) {
-    const [first, second] = args;
-    if (typeof first === "string") {
-      const options = second ?? {};
-      return {
-        exclude: { columns, options: { ...options, name: first } }
-      };
-    } else {
-      const options = first ?? {};
-      return {
-        exclude: { columns, options }
-      };
-    }
-  },
-  foreignKey(columns, fnOrTable, foreignColumns, options) {
-    return {
-      constraint: {
-        name: options?.name,
-        references: { columns, fnOrTable, foreignColumns, options }
-      }
-    };
-  },
-  check(check, name) {
-    return { constraint: { check, name } };
-  },
-  sql: sqlFn
-};
-const parseTableData = (dataFn) => {
-  const tableData = {};
-  if (dataFn) {
-    const input = dataFn(tableDataMethods);
-    if (Array.isArray(input)) {
-      for (const item of input) {
-        parseTableDataInput(tableData, item);
-      }
-    } else {
-      parseTableDataInput(tableData, input);
-    }
-  }
-  return tableData;
-};
-const parseTableDataInput = (tableData, item) => {
-  if (item.primaryKey) {
-    tableData.primaryKey = item.primaryKey;
-  } else if (item.index) {
-    (tableData.indexes ?? (tableData.indexes = [])).push(
-      parseIndexOrExclude(item.index)
-    );
-  } else if (item.exclude) {
-    (tableData.excludes ?? (tableData.excludes = [])).push(
-      parseIndexOrExclude(item.exclude)
-    );
-  } else if (item.constraint) {
-    (tableData.constraints ?? (tableData.constraints = [])).push(item.constraint);
-    if (item.constraint.references?.options?.dropMode) {
-      item.constraint.dropMode = item.constraint.references.options.dropMode;
-    }
-  }
-};
-const parseIndexOrExclude = (item) => {
-  for (let i = item.columns.length - 1; i >= 0; i--) {
-    if (typeof item.columns[i] === "string") {
-      item.columns[i] = {
-        column: item.columns[i]
-      };
-    }
-  }
-  return item;
-};
-
 const performQuery = async (q, args, method) => {
   const trx = q.internal.asyncStorage.getStore();
   let sql;
@@ -16085,6 +16193,126 @@ const _initQueryBuilder = (adapter, columnTypes, asyncStorage, commonOptions, op
   return qb.qb = qb;
 };
 
+const setConnectRetryConfig = (adapter, config) => {
+  adapter.connectRetryConfig = {
+    attempts: config.attempts ?? 10,
+    strategy: typeof config.strategy === "function" ? config.strategy : defaultConnectRetryStrategy(config.strategy ?? emptyObject)
+  };
+};
+const wrapAdapterFnWithConnectRetry = (adapter, fn) => {
+  return async function(...args) {
+    let attempt = 1;
+    for (; ; ) {
+      try {
+        return await fn.call(this, ...args);
+      } catch (err) {
+        const config = adapter.connectRetryConfig;
+        if (!err || typeof err !== "object" || err.code !== "ECONNREFUSED" || !config || attempt >= config.attempts) {
+          throw err;
+        }
+        await config.strategy(attempt, config.attempts);
+        attempt++;
+      }
+    }
+  };
+};
+const defaultConnectRetryStrategy = (param) => {
+  return (attempt) => promises.setTimeout((param.factor ?? 1.5) ** (attempt - 1) * (param.delay ?? 50));
+};
+
+const makeColumnInfoSql = (query, column) => {
+  const values = [];
+  const schema = getQuerySchema(query);
+  let text = `SELECT * FROM information_schema.columns WHERE table_name = ${addValue(
+    values,
+    query.table
+  )} AND table_catalog = current_database() AND table_schema = ${schema ? addValue(values, schema) : "current_schema()"}`;
+  if (column) {
+    text += ` AND column_name = ${addValue(
+      values,
+      query.q.shape[column]?.data.name || column
+    )}`;
+  }
+  return {
+    text,
+    values
+  };
+};
+
+const rowToColumnInfo = (row) => {
+  const typed = row;
+  return {
+    defaultValue: typed.column_default,
+    type: typed.data_type,
+    maxLength: typed.character_maximum_length,
+    nullable: typed.is_nullable === "YES"
+  };
+};
+function getColumnInfo(query, column) {
+  const q = Object.create(internal._clone(query));
+  q.toSQL = () => makeColumnInfoSql(query, column);
+  q.q.handleResult = (_, _t, result) => {
+    if (column) {
+      return rowToColumnInfo(result.rows[0]);
+    } else {
+      const info = {};
+      result.rows.forEach((row) => {
+        info[row.column_name] = rowToColumnInfo(row);
+      });
+      return info;
+    }
+  };
+  return q;
+}
+
+const makeCopySql = (table, copy) => {
+  const ctx = newToSqlCtx(table);
+  const { q } = table;
+  const quotedAs = `"${q.as || table.table}"`;
+  const columns = copy.columns ? `(${copy.columns.map((item) => `"${q.shape[item]?.data.name || item}"`).join(", ")})` : "";
+  const target = "from" in copy ? copy.from : copy.to;
+  const quotedTable = quoteTableWithSchema(table);
+  ctx.sql.push(
+    `COPY ${quotedTable}${columns} ${"from" in copy ? "FROM" : "TO"} ${typeof target === "string" ? escapeString(target) : `PROGRAM ${escapeString(target.program)}`}`
+  );
+  if (Object.keys(copy).length > (copy.columns ? 2 : 1)) {
+    const options = [];
+    if (copy.format) options.push(`FORMAT ${copy.format}`);
+    if (copy.freeze) options.push(`FREEZE ${copy.freeze}`);
+    if (copy.delimiter)
+      options.push(`DELIMITER ${escapeString(copy.delimiter)}`);
+    if (copy.null) options.push(`NULL ${escapeString(copy.null)}`);
+    if (copy.header) options.push(`HEADER ${copy.header}`);
+    if (copy.quote) options.push(`QUOTE ${escapeString(copy.quote)}`);
+    if (copy.escape) options.push(`ESCAPE ${escapeString(copy.escape)}`);
+    if (copy.forceQuote)
+      options.push(
+        `FORCE_QUOTE ${copy.forceQuote === "*" ? "*" : `(${copy.forceQuote.map((x) => `"${x}"`).join(", ")})`}`
+      );
+    if (copy.forceNotNull)
+      options.push(
+        `FORCE_NOT_NULL (${copy.forceNotNull.map((x) => `"${x}"`).join(", ")})`
+      );
+    if (copy.forceNull)
+      options.push(
+        `FORCE_NULL (${copy.forceNull.map((x) => `"${x}"`).join(", ")})`
+      );
+    if (copy.encoding) options.push(`ENCODING ${escapeString(copy.encoding)}`);
+    ctx.sql.push(`WITH (${options.join(", ")})`);
+  }
+  pushWhereStatementSql(ctx, table, q, quotedAs);
+  return {
+    text: ctx.sql.join(" "),
+    values: ctx.values
+  };
+};
+
+function copyTableData(query, arg) {
+  const q = Object.create(query);
+  q.toSQL = () => makeCopySql(q, arg);
+  return q;
+}
+
 class Rollback extends Error {
 }
 const trxForTest = Symbol("trxForTest");
@@ -16169,7 +16397,6 @@ const testTransaction = {
   }
 };
 
-exports.AfterCommitError = AfterCommitError;
 exports.ArrayColumn = ArrayColumn;
 exports.BigIntColumn = BigIntColumn;
 exports.BigSerialColumn = BigSerialColumn;
@@ -16182,9 +16409,6 @@ exports.CidrColumn = CidrColumn;
 exports.CircleColumn = CircleColumn;
 exports.CitextColumn = CitextColumn;
 exports.Column = Column;
-exports.ColumnRefExpression = ColumnRefExpression;
-exports.ComputedColumn = ComputedColumn;
-exports.CteQuery = CteQuery;
 exports.CustomTypeColumn = CustomTypeColumn;
 exports.DateBaseColumn = DateBaseColumn;
 exports.DateColumn = DateColumn;
@@ -16197,9 +16421,6 @@ exports.DoublePrecisionColumn = DoublePrecisionColumn;
 exports.DynamicRawSQL = DynamicRawSQL;
 exports.EnumColumn = EnumColumn;
 exports.Expression = Expression;
-exports.ExpressionTypeMethod = ExpressionTypeMethod;
-exports.FnExpression = FnExpression;
-exports.FromMethods = FromMethods;
 exports.InetColumn = InetColumn;
 exports.IntegerBaseColumn = IntegerBaseColumn;
 exports.IntegerColumn = IntegerColumn;
@@ -16211,128 +16432,58 @@ exports.LineColumn = LineColumn;
 exports.LsegColumn = LsegColumn;
 exports.MacAddr8Column = MacAddr8Column;
 exports.MacAddrColumn = MacAddrColumn;
-exports.MergeQueryMethods = MergeQueryMethods;
 exports.MoneyColumn = MoneyColumn;
-exports.MoreThanOneRowError = MoreThanOneRowError;
 exports.NotFoundError = NotFoundError;
 exports.NumberAsStringBaseColumn = NumberAsStringBaseColumn;
 exports.NumberBaseColumn = NumberBaseColumn;
-exports.OnConflictQueryBuilder = OnConflictQueryBuilder;
-exports.OnMethods = OnMethods;
 exports.Operators = Operators;
-exports.OrExpression = OrExpression;
-exports.OrchidOrmError = OrchidOrmError;
 exports.OrchidOrmInternalError = OrchidOrmInternalError;
 exports.PathColumn = PathColumn;
 exports.PointColumn = PointColumn;
 exports.PolygonColumn = PolygonColumn;
 exports.PostgisGeographyPointColumn = PostgisGeographyPointColumn;
-exports.QueryAsMethods = QueryAsMethods;
-exports.QueryClone = QueryClone;
-exports.QueryCreate = QueryCreate;
-exports.QueryCreateFrom = QueryCreateFrom;
-exports.QueryDelete = QueryDelete;
 exports.QueryError = QueryError;
-exports.QueryExpressions = QueryExpressions;
-exports.QueryGet = QueryGet;
 exports.QueryHookUtils = QueryHookUtils;
 exports.QueryHooks = QueryHooks;
-exports.QueryJoin = QueryJoin;
-exports.QueryLog = QueryLog;
-exports.QueryMethods = QueryMethods;
-exports.QueryOrCreate = QueryOrCreate;
-exports.QueryScope = QueryScope;
-exports.QuerySql = QuerySql;
-exports.QueryTransaction = QueryTransaction;
-exports.QueryTransform = QueryTransform;
-exports.QueryUpdate = QueryUpdate;
-exports.QueryUpsert = QueryUpsert;
-exports.QueryWithSchema = QueryWithSchema;
-exports.QueryWrap = QueryWrap;
 exports.RawSql = RawSql;
 exports.RealColumn = RealColumn;
-exports.RefExpression = RefExpression;
-exports.Select = Select;
 exports.SerialColumn = SerialColumn;
 exports.SmallIntColumn = SmallIntColumn;
 exports.SmallSerialColumn = SmallSerialColumn;
-exports.SqlRefExpression = SqlRefExpression;
 exports.StringColumn = StringColumn;
 exports.TextBaseColumn = TextBaseColumn;
 exports.TextColumn = TextColumn;
-exports.Then = Then;
 exports.TimeColumn = TimeColumn;
 exports.TimestampColumn = TimestampColumn;
 exports.TimestampTZColumn = TimestampTZColumn;
 exports.TsQueryColumn = TsQueryColumn;
 exports.TsVectorColumn = TsVectorColumn;
 exports.UUIDColumn = UUIDColumn;
-exports.UnhandledTypeError = UnhandledTypeError;
 exports.UnknownColumn = UnknownColumn;
-exports.UnsafeSqlExpression = UnsafeSqlExpression;
 exports.VarCharColumn = VarCharColumn;
 exports.VirtualColumn = VirtualColumn;
-exports.Where = Where;
 exports.XMLColumn = XMLColumn;
-exports._addToHookSelect = _addToHookSelect;
-exports._addToHookSelectWithTable = _addToHookSelectWithTable;
 exports._appendQuery = _appendQuery;
-exports._applyRelationAliases = _applyRelationAliases;
-exports._checkIfAliased = _checkIfAliased;
 exports._clone = _clone;
-exports._copyQueryAliasToQuery = _copyQueryAliasToQuery;
 exports._createDbSqlMethod = _createDbSqlMethod;
-exports._getQueryAliasOrName = _getQueryAliasOrName;
-exports._getQueryAs = _getQueryAs;
-exports._getQueryFreeAlias = _getQueryFreeAlias;
-exports._getQueryOuterAliases = _getQueryOuterAliases;
 exports._hookSelectColumns = _hookSelectColumns;
 exports._initQueryBuilder = _initQueryBuilder;
-exports._join = _join;
-exports._joinLateral = _joinLateral;
-exports._joinLateralProcessArg = _joinLateralProcessArg;
-exports._joinReturningArgs = _joinReturningArgs;
 exports._orCreate = _orCreate;
 exports._prependWith = _prependWith;
-exports._queryAfterSaveCommit = _queryAfterSaveCommit;
-exports._queryAll = _queryAll;
-exports._queryChangeCounter = _queryChangeCounter;
 exports._queryCreate = _queryCreate;
-exports._queryCreateForEachFrom = _queryCreateForEachFrom;
 exports._queryCreateMany = _queryCreateMany;
 exports._queryCreateManyFrom = _queryCreateManyFrom;
-exports._queryCreateOneFrom = _queryCreateOneFrom;
 exports._queryDefaults = _queryDefaults;
 exports._queryDelete = _queryDelete;
-exports._queryExec = _queryExec;
 exports._queryFindBy = _queryFindBy;
 exports._queryFindByOptional = _queryFindByOptional;
 exports._queryHookAfterCreate = _queryHookAfterCreate;
-exports._queryHookAfterCreateCommit = _queryHookAfterCreateCommit;
-exports._queryHookAfterDelete = _queryHookAfterDelete;
-exports._queryHookAfterDeleteCommit = _queryHookAfterDeleteCommit;
-exports._queryHookAfterQuery = _queryHookAfterQuery;
-exports._queryHookAfterSave = _queryHookAfterSave;
 exports._queryHookAfterUpdate = _queryHookAfterUpdate;
-exports._queryHookAfterUpdateCommit = _queryHookAfterUpdateCommit;
-exports._queryHookBeforeCreate = _queryHookBeforeCreate;
-exports._queryHookBeforeDelete = _queryHookBeforeDelete;
-exports._queryHookBeforeQuery = _queryHookBeforeQuery;
-exports._queryHookBeforeSave = _queryHookBeforeSave;
-exports._queryHookBeforeUpdate = _queryHookBeforeUpdate;
 exports._queryInsert = _queryInsert;
-exports._queryInsertForEachFrom = _queryInsertForEachFrom;
 exports._queryInsertMany = _queryInsertMany;
-exports._queryInsertManyFrom = _queryInsertManyFrom;
-exports._queryInsertOneFrom = _queryInsertOneFrom;
 exports._queryJoinOn = _queryJoinOn;
-exports._queryJoinOnJsonPathEquals = _queryJoinOnJsonPathEquals;
-exports._queryJoinOrOn = _queryJoinOrOn;
-exports._queryOr = _queryOr;
-exports._queryOrNot = _queryOrNot;
 exports._queryRows = _queryRows;
 exports._querySelect = _querySelect;
-exports._querySelectAll = _querySelectAll;
 exports._queryTake = _queryTake;
 exports._queryTakeOptional = _queryTakeOptional;
 exports._queryUpdate = _queryUpdate;
@@ -16341,236 +16492,88 @@ exports._queryUpsert = _queryUpsert;
 exports._queryWhere = _queryWhere;
 exports._queryWhereExists = _queryWhereExists;
 exports._queryWhereIn = _queryWhereIn;
-exports._queryWhereNot = _queryWhereNot;
-exports._queryWhereNotExists = _queryWhereNotExists;
-exports._queryWhereNotOneOf = _queryWhereNotOneOf;
-exports._queryWhereNotSql = _queryWhereNotSql;
-exports._queryWhereOneOf = _queryWhereOneOf;
-exports._queryWhereSql = _queryWhereSql;
-exports._runAfterCommitHooks = _runAfterCommitHooks;
-exports._setQueryAlias = _setQueryAlias;
-exports._setQueryAs = _setQueryAs;
-exports._setSubQueryAliases = _setSubQueryAliases;
-exports._with = _with;
 exports.addCode = addCode;
-exports.addColumnParserToQuery = addColumnParserToQuery;
-exports.addParserForRawExpression = addParserForRawExpression;
-exports.addParserForSelectItem = addParserForSelectItem;
-exports.addQueryOn = addQueryOn;
 exports.addTopCte = addTopCte;
 exports.addTopCteSql = addTopCteSql;
-exports.addValue = addValue;
-exports.addWithToSql = addWithToSql;
-exports.anyShape = anyShape;
-exports.applyBatchTransforms = applyBatchTransforms;
-exports.applyComputedColumns = applyComputedColumns;
 exports.applyMixins = applyMixins;
-exports.applyTransforms = applyTransforms;
-exports.arrayDataToCode = arrayDataToCode;
-exports.arrayMethodNames = arrayMethodNames;
 exports.assignDbDataToColumn = assignDbDataToColumn;
 exports.backtickQuote = backtickQuote;
-exports.callWithThis = callWithThis;
-exports.checkIfASimpleQuery = checkIfASimpleQuery;
 exports.cloneQueryBaseUnscoped = cloneQueryBaseUnscoped;
 exports.codeToString = codeToString;
 exports.colors = colors;
-exports.columnCheckToCode = columnCheckToCode;
-exports.columnCode = columnCode;
-exports.columnDefaultArgumentToCode = columnDefaultArgumentToCode;
-exports.columnErrorMessagesToCode = columnErrorMessagesToCode;
-exports.columnExcludesToCode = columnExcludesToCode;
-exports.columnForeignKeysToCode = columnForeignKeysToCode;
-exports.columnIndexesToCode = columnIndexesToCode;
-exports.columnMethodsToCode = columnMethodsToCode;
 exports.columnsShapeToCode = columnsShapeToCode;
-exports.commitSql = commitSql;
-exports.composeCteSingleSql = composeCteSingleSql;
 exports.constraintInnerToCode = constraintInnerToCode;
-exports.constraintToCode = constraintToCode;
 exports.consumeColumnName = consumeColumnName;
-exports.countSelect = countSelect;
-exports.createCtx = createCtx;
+exports.copyTableData = copyTableData;
 exports.createDbWithAdapter = createDbWithAdapter;
-exports.createSelect = createSelect;
-exports.cteToSql = cteToSql;
-exports.cteToSqlGiveAs = cteToSqlGiveAs;
-exports.ctesToSql = ctesToSql;
-exports.dateDataToCode = dateDataToCode;
-exports.dateMethodNames = dateMethodNames;
 exports.deepCompare = deepCompare;
 exports.defaultSchemaConfig = defaultSchemaConfig;
 exports.emptyArray = emptyArray;
 exports.emptyObject = emptyObject;
-exports.escapeForLog = escapeForLog;
 exports.escapeForMigration = escapeForMigration;
 exports.escapeString = escapeString;
 exports.excludeInnerToCode = excludeInnerToCode;
-exports.excludeToCode = excludeToCode;
 exports.exhaustive = exhaustive;
-exports.extendQuery = extendQuery;
-exports.filterResult = filterResult;
-exports.finalizeNestedHookSelect = finalizeNestedHookSelect;
-exports.foreignKeyArgumentToCode = foreignKeyArgumentToCode;
 exports.getCallerFilePath = getCallerFilePath;
 exports.getClonedQueryData = getClonedQueryData;
 exports.getColumnBaseType = getColumnBaseType;
+exports.getColumnInfo = getColumnInfo;
 exports.getColumnTypes = getColumnTypes;
-exports.getDefaultLanguage = getDefaultLanguage;
-exports.getDefaultNowFn = getDefaultNowFn;
 exports.getFreeAlias = getFreeAlias;
 exports.getFreeSetAlias = getFreeSetAlias;
-exports.getFromSelectColumns = getFromSelectColumns;
-exports.getFullColumnTable = getFullColumnTable;
 exports.getImportPath = getImportPath;
 exports.getPrimaryKeys = getPrimaryKeys;
 exports.getQueryAs = getQueryAs;
 exports.getQuerySchema = getQuerySchema;
-exports.getSearchLang = getSearchLang;
-exports.getSearchText = getSearchText;
 exports.getShapeFromSelect = getShapeFromSelect;
 exports.getSqlText = getSqlText;
 exports.getStackTrace = getStackTrace;
 exports.getSupportedDefaultPrivileges = getSupportedDefaultPrivileges;
-exports.getThen = getThen;
-exports.getTopCteSize = getTopCteSize;
-exports.handleManyData = handleManyData;
-exports.handleOneData = handleOneData;
-exports.handleResult = handleResult;
-exports.havingToSql = havingToSql;
-exports.identityToCode = identityToCode;
 exports.indexInnerToCode = indexInnerToCode;
-exports.indexToCode = indexToCode;
-exports.insert = insert;
-exports.isDefaultTimeStamp = isDefaultTimeStamp;
 exports.isExpression = isExpression;
-exports.isInUserTransaction = isInUserTransaction;
-exports.isIterable = isIterable;
-exports.isObjectEmpty = isObjectEmpty;
-exports.isQuery = isQuery;
 exports.isQueryReturnsAll = isQueryReturnsAll;
 exports.isRawSQL = isRawSQL;
-exports.isRelationQuery = isRelationQuery;
-exports.isTemplateLiteralArgs = isTemplateLiteralArgs;
-exports.joinSubQuery = joinSubQuery;
-exports.joinTruthy = joinTruthy;
 exports.logColors = logColors;
 exports.logParamToLogObject = logParamToLogObject;
 exports.makeColumnNullable = makeColumnNullable;
 exports.makeColumnTypes = makeColumnTypes;
 exports.makeColumnsByType = makeColumnsByType;
-exports.makeFnExpression = makeFnExpression;
-exports.makeInsertSql = makeInsertSql;
-exports.makeReturningSql = makeReturningSql;
-exports.makeRowToJson = makeRowToJson;
-exports.makeSql = makeSql;
-exports.moveMutativeQueryToCte = moveMutativeQueryToCte;
-exports.newDelayedRelationSelect = newDelayedRelationSelect;
 exports.noop = noop;
-exports.numberDataToCode = numberDataToCode;
-exports.numberMethodNames = numberMethodNames;
 exports.objectHasValues = objectHasValues;
 exports.omit = omit;
-exports.orderByToSql = orderByToSql;
-exports.parseRecord = parseRecord;
 exports.parseTableData = parseTableData;
 exports.parseTableDataInput = parseTableDataInput;
 exports.pathToLog = pathToLog;
 exports.pick = pick;
 exports.pluralize = pluralize;
-exports.postgisTypmodToSql = postgisTypmodToSql;
-exports.prepareOpArg = prepareOpArg;
 exports.prepareSubQueryForSql = prepareSubQueryForSql;
 exports.primaryKeyInnerToCode = primaryKeyInnerToCode;
-exports.processComputedBatches = processComputedBatches;
-exports.processComputedResult = processComputedResult;
-exports.processJoinItem = processJoinItem;
-exports.processSelectArg = processSelectArg;
-exports.pushColumnData = pushColumnData;
-exports.pushHavingSql = pushHavingSql;
-exports.pushJoinSql = pushJoinSql;
-exports.pushOrNewArray = pushOrNewArray;
-exports.pushOrNewArrayToObjectImmutable = pushOrNewArrayToObjectImmutable;
-exports.pushOrderBySql = pushOrderBySql;
-exports.pushQueryArrayImmutable = pushQueryArrayImmutable;
-exports.pushQueryOn = pushQueryOn;
 exports.pushQueryOnForOuter = pushQueryOnForOuter;
-exports.pushQueryOrOn = pushQueryOrOn;
 exports.pushQueryValueImmutable = pushQueryValueImmutable;
 exports.pushTableDataCode = pushTableDataCode;
-exports.pushUnionSql = pushUnionSql;
-exports.pushWhereStatementSql = pushWhereStatementSql;
-exports.pushWhereToSql = pushWhereToSql;
-exports.queryColumnNameToKey = queryColumnNameToKey;
-exports.queryFrom = queryFrom;
-exports.queryFromSql = queryFromSql;
-exports.queryMethodByReturnType = queryMethodByReturnType;
-exports.queryTypeWithLimitOne = queryTypeWithLimitOne;
-exports.queryWrap = queryWrap;
-exports.quoteFromWithSchema = quoteFromWithSchema;
 exports.quoteObjectKey = quoteObjectKey;
-exports.quoteSchemaAndTable = quoteSchemaAndTable;
 exports.quoteTableWithSchema = quoteTableWithSchema;
 exports.raw = raw$1;
 exports.rawSqlToCode = rawSqlToCode;
 exports.referencesArgsToCode = referencesArgsToCode;
-exports.requirePrimaryKeys = requirePrimaryKeys;
-exports.requireQueryAs = requireQueryAs;
-exports.requireTableOrStringFrom = requireTableOrStringFrom;
-exports.resetDefaultNowFn = resetDefaultNowFn;
-exports.resolveSubQueryCallback = resolveSubQueryCallback;
 exports.returnArg = returnArg;
-exports.rollbackSql = rollbackSql;
-exports.saveAliasedShape = saveAliasedShape;
-exports.searchSourcesToSql = searchSourcesToSql;
-exports.selectAllSql = selectAllSql;
-exports.selectToSql = selectToSql;
-exports.selectToSqlList = selectToSqlList;
 exports.setColumnData = setColumnData;
-exports.setColumnDefaultParse = setColumnDefaultParse;
 exports.setColumnEncode = setColumnEncode;
 exports.setColumnParse = setColumnParse;
 exports.setColumnParseNull = setColumnParseNull;
 exports.setConnectRetryConfig = setConnectRetryConfig;
 exports.setCurrentColumnName = setCurrentColumnName;
 exports.setDataValue = setDataValue;
-exports.setDb = setDb;
 exports.setDefaultLanguage = setDefaultLanguage;
-exports.setDefaultNowFn = setDefaultNowFn;
-exports.setDelayedRelation = setDelayedRelation;
 exports.setFreeAlias = setFreeAlias;
-exports.setFreeTopCteAs = setFreeTopCteAs;
-exports.setMoveMutativeQueryToCte = setMoveMutativeQueryToCte;
-exports.setObjectValueImmutable = setObjectValueImmutable;
-exports.setParserForSelectedString = setParserForSelectedString;
-exports.setPrepareSubQueryForSql = setPrepareSubQueryForSql;
 exports.setQueryObjectValueImmutable = setQueryObjectValueImmutable;
-exports.setQueryOperators = setQueryOperators;
-exports.setRawSqlPrepareSubQueryForSql = setRawSqlPrepareSubQueryForSql;
-exports.setSqlCtxSelectList = setSqlCtxSelectList;
-exports.setTopCteSize = setTopCteSize;
 exports.singleQuote = singleQuote;
-exports.singleQuoteArray = singleQuoteArray;
 exports.snakeCaseKey = snakeCaseKey;
-exports.spreadObjectValues = spreadObjectValues;
-exports.sqlFn = sqlFn;
-exports.sqlQueryArgsToExpression = sqlQueryArgsToExpression;
-exports.stringDataToCode = stringDataToCode;
-exports.stringMethodNames = stringMethodNames;
 exports.tableDataMethods = tableDataMethods;
-exports.templateLiteralSQLToCode = templateLiteralSQLToCode;
-exports.templateLiteralToSQL = templateLiteralToSQL;
 exports.testTransaction = testTransaction;
-exports.throwIfJoinLateral = throwIfJoinLateral;
-exports.throwIfNoWhere = throwIfNoWhere;
-exports.throwOnReadOnly = throwOnReadOnly;
-exports.throwOnReadOnlyUpdate = throwOnReadOnlyUpdate;
-exports.timestampHelpers = timestampHelpers;
 exports.toArray = toArray;
 exports.toCamelCase = toCamelCase;
 exports.toPascalCase = toPascalCase;
 exports.toSnakeCase = toSnakeCase;
-exports.whereToSql = whereToSql;
-exports.windowToSql = windowToSql;
 exports.wrapAdapterFnWithConnectRetry = wrapAdapterFnWithConnectRetry;
 //# sourceMappingURL=index.js.map