pqb 0.27.1 → 0.27.2

package/dist/index.js

@@ -102,25 +102,25 @@ function sqlQueryArgsToExpression(args) {
   return Array.isArray(args[0]) ? new RawSQL(args) : args[0];
 }
 
-var __defProp$g = Object.defineProperty;
-var __defProps$a = Object.defineProperties;
-var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$h = Object.getOwnPropertySymbols;
-var __hasOwnProp$h = Object.prototype.hasOwnProperty;
-var __propIsEnum$h = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$g = (a, b) => {
+var __defProp$h = Object.defineProperty;
+var __defProps$b = Object.defineProperties;
+var __getOwnPropDescs$b = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$i = Object.getOwnPropertySymbols;
+var __hasOwnProp$i = Object.prototype.hasOwnProperty;
+var __propIsEnum$i = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$h = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$h.call(b, prop))
-      __defNormalProp$g(a, prop, b[prop]);
-  if (__getOwnPropSymbols$h)
-    for (var prop of __getOwnPropSymbols$h(b)) {
-      if (__propIsEnum$h.call(b, prop))
-        __defNormalProp$g(a, prop, b[prop]);
+    if (__hasOwnProp$i.call(b, prop))
+      __defNormalProp$h(a, prop, b[prop]);
+  if (__getOwnPropSymbols$i)
+    for (var prop of __getOwnPropSymbols$i(b)) {
+      if (__propIsEnum$i.call(b, prop))
+        __defNormalProp$h(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
+var __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
 class ColumnType extends orchidCore.ColumnTypeBase {
   /**
    * Mark the column as a primary key.
@@ -146,7 +146,7 @@ class ColumnType extends orchidCore.ColumnTypeBase {
     return orchidCore.setColumnData(this, "isPrimaryKey", true);
   }
   foreignKey(fnOrTable, column, options = orchidCore.emptyObject) {
-    const item = typeof fnOrTable === "string" ? __spreadValues$g({ table: fnOrTable, columns: [column] }, options) : __spreadValues$g({ fn: fnOrTable, columns: [column] }, options);
+    const item = typeof fnOrTable === "string" ? __spreadValues$h({ table: fnOrTable, columns: [column] }, options) : __spreadValues$h({ fn: fnOrTable, columns: [column] }, options);
     return orchidCore.pushColumnData(this, "foreignKeys", item);
   }
   toSQL() {
@@ -203,10 +203,10 @@ class ColumnType extends orchidCore.ColumnTypeBase {
    * @param options - index options
    */
   searchIndex(options) {
-    return orchidCore.pushColumnData(this, "indexes", __spreadValues$g(__spreadValues$g({}, options), this.dataType === "tsvector" ? { using: "GIN" } : { tsVector: true }));
+    return orchidCore.pushColumnData(this, "indexes", __spreadValues$h(__spreadValues$h({}, options), this.dataType === "tsvector" ? { using: "GIN" } : { tsVector: true }));
   }
   unique(options = {}) {
-    return orchidCore.pushColumnData(this, "indexes", __spreadProps$a(__spreadValues$g({}, options), { unique: true }));
+    return orchidCore.pushColumnData(this, "indexes", __spreadProps$b(__spreadValues$h({}, options), { unique: true }));
   }
   comment(comment) {
     return orchidCore.setColumnData(this, "comment", comment);
@@ -244,25 +244,25 @@ class ColumnType extends orchidCore.ColumnTypeBase {
   }
 }
 
-var __defProp$f = Object.defineProperty;
-var __defProps$9 = Object.defineProperties;
-var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
-var __hasOwnProp$g = Object.prototype.hasOwnProperty;
-var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$f = (a, b) => {
+var __defProp$g = Object.defineProperty;
+var __defProps$a = Object.defineProperties;
+var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$h = Object.getOwnPropertySymbols;
+var __hasOwnProp$h = Object.prototype.hasOwnProperty;
+var __propIsEnum$h = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$g = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$g.call(b, prop))
-      __defNormalProp$f(a, prop, b[prop]);
-  if (__getOwnPropSymbols$g)
-    for (var prop of __getOwnPropSymbols$g(b)) {
-      if (__propIsEnum$g.call(b, prop))
-        __defNormalProp$f(a, prop, b[prop]);
+    if (__hasOwnProp$h.call(b, prop))
+      __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$h)
+    for (var prop of __getOwnPropSymbols$h(b)) {
+      if (__propIsEnum$h.call(b, prop))
+        __defNormalProp$g(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+var __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
 const knownDefaults = {
   current_timestamp: "now()",
   "transaction_timestamp()": "now()"
@@ -276,7 +276,7 @@ const simplifyColumnDefault = (value) => {
 };
 const instantiateColumn = (typeFn, params) => {
   const column = typeFn();
-  Object.assign(column.data, __spreadProps$9(__spreadValues$f({}, params), {
+  Object.assign(column.data, __spreadProps$a(__spreadValues$g({}, params), {
     default: simplifyColumnDefault(params.default)
   }));
   return column;
@@ -993,14 +993,14 @@ const processWhere = (ands, ctx, table, query, data, quotedAs) => {
       const joinItems = Array.isArray(value[0]) ? value : [value];
       const joinSet = joinItems.length > 1 ? /* @__PURE__ */ new Set() : null;
       for (const args of joinItems) {
-        const { target, conditions } = processJoinItem(
+        const { target, on } = processJoinItem(
           ctx,
           table,
           query,
           args,
           quotedAs
         );
-        const sql = `EXISTS (SELECT 1 FROM ${target} WHERE ${conditions})`;
+        const sql = `EXISTS (SELECT 1 FROM ${target}${on ? ` WHERE ${on}` : ""})`;
         if (joinSet) {
           if (joinSet.has(sql))
             continue;
@@ -1091,190 +1091,144 @@ const pushIn = (ctx, query, ands, quotedAs, arg) => {
   ands.push(`${multiple ? `(${columnsSql})` : columnsSql} IN ${value}`);
 };
 
-var __defProp$e = Object.defineProperty;
-var __defProps$8 = Object.defineProperties;
-var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
-var __hasOwnProp$f = Object.prototype.hasOwnProperty;
-var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$e = (a, b) => {
+var __defProp$f = Object.defineProperty;
+var __defProps$9 = Object.defineProperties;
+var __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$f = (a, b) => {
   for (var prop in b || (b = {}))
-    if (__hasOwnProp$f.call(b, prop))
-      __defNormalProp$e(a, prop, b[prop]);
-  if (__getOwnPropSymbols$f)
-    for (var prop of __getOwnPropSymbols$f(b)) {
-      if (__propIsEnum$f.call(b, prop))
-        __defNormalProp$e(a, prop, b[prop]);
+    if (__hasOwnProp$g.call(b, prop))
+      __defNormalProp$f(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b)) {
+      if (__propIsEnum$g.call(b, prop))
+        __defNormalProp$f(a, prop, b[prop]);
     }
   return a;
 };
-var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
-const processJoinItem = (ctx, table, query, item, quotedAs) => {
+var __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
+const processJoinItem = (ctx, table, query, args, quotedAs) => {
   let target;
-  let conditions;
-  const { first, args } = item;
-  if (typeof first === "string") {
-    if (first in table.relations) {
-      const { query: toQuery, joinQuery } = table.relations[first].relationConfig;
-      const jq = joinQuery(toQuery, table);
-      const { q: j } = jq;
-      const tableName = typeof j.from === "string" ? j.from : jq.table;
-      target = quoteSchemaAndTable(j.schema, tableName);
-      const as = j.as || first;
-      const joinAs = `"${as}"`;
-      if (as !== tableName) {
-        target += ` AS ${joinAs}`;
-      }
-      const queryData = {
-        shape: j.shape,
-        joinedShapes: __spreadProps$8(__spreadValues$e(__spreadValues$e({}, query.joinedShapes), j.joinedShapes), {
-          [table.q.as || table.table]: table.shape
-        }),
-        and: j.and ? [...j.and] : [],
-        or: j.or ? [...j.or] : []
-      };
-      if (args[0]) {
-        const arg = args[0](
-          new ctx.queryBuilder.onQueryBuilder(jq, j, table)
-        ).q;
-        if (arg.and)
-          queryData.and.push(...arg.and);
-        if (arg.or)
-          queryData.or.push(...arg.or);
+  let on;
+  if ("j" in args) {
+    const { j, s, r } = args;
+    const tableName = typeof j.q.from === "string" ? j.q.from : j.table;
+    const quotedTable = quoteSchemaAndTable(j.q.schema, tableName);
+    target = quotedTable;
+    const as = j.q.as;
+    const joinAs = `"${as}"`;
+    if (as !== tableName) {
+      target += ` AS ${joinAs}`;
+    }
+    if (r && s) {
+      target = `LATERAL ${subJoinToSql(ctx, j, quotedTable, joinAs, true)}`;
+    } else {
+      on = whereToSql(ctx, j, j.q, joinAs);
+    }
+  } else if ("w" in args) {
+    const { w } = args;
+    target = `"${w}"`;
+    if ("r" in args) {
+      const { s, r } = args;
+      if (s) {
+        target = `LATERAL ${subJoinToSql(ctx, r, target, target)}`;
+      } else {
+        on = whereToSql(ctx, r, r.q, target);
       }
-      conditions = whereToSql(ctx, jq, queryData, joinAs);
     } else {
-      target = `"${first}"`;
-      const joinShape = query.joinedShapes[first];
-      conditions = processArgs(
-        args,
+      on = processArgs(
+        args.a,
         ctx,
-        table,
         query,
-        first,
         target,
-        joinShape,
+        query.joinedShapes[w],
         quotedAs
       );
     }
   } else {
-    const joinQuery = first.q;
-    const quotedFrom = typeof joinQuery.from === "string" ? `"${joinQuery.from}"` : void 0;
-    target = quotedFrom || quoteSchemaAndTable(joinQuery.schema, first.table);
-    let joinAs = quotedFrom || `"${first.table}"`;
-    const qAs = joinQuery.as ? `"${joinQuery.as}"` : void 0;
-    const addAs = qAs && qAs !== joinAs;
-    const joinedShape = first.shape;
-    if (item.isSubQuery) {
-      const subQuery = first.toSQL({
-        values: ctx.values
-      });
-      target = `(${subQuery.text}) ${qAs || joinAs}`;
-      if (addAs)
-        joinAs = qAs;
+    const { q, s } = args;
+    let joinAs;
+    if ("r" in args) {
+      const { r } = args;
+      const res = getArgQueryTarget(ctx, q, s, s);
+      target = s ? `LATERAL ${res.target}` : res.target;
+      joinAs = res.joinAs;
+      if (!s) {
+        on = whereToSql(ctx, r, r.q, joinAs);
+      }
     } else {
-      if (addAs) {
-        joinAs = qAs;
-        target += ` AS ${qAs}`;
+      const res = getArgQueryTarget(ctx, q, s);
+      target = res.target;
+      joinAs = res.joinAs;
+      if ("a" in args) {
+        on = processArgs(args.a, ctx, query, joinAs, q.shape, quotedAs);
       }
     }
-    conditions = processArgs(
-      args,
-      ctx,
-      table,
-      query,
-      first,
-      joinAs,
-      joinedShape,
-      quotedAs
-    );
-    if (!item.isSubQuery) {
+    if (!s) {
       const whereSql = whereToSql(
         ctx,
-        first,
-        __spreadProps$8(__spreadValues$e({}, joinQuery), {
-          joinedShapes: __spreadProps$8(__spreadValues$e(__spreadValues$e({}, query.joinedShapes), joinQuery.joinedShapes), {
+        q,
+        __spreadProps$9(__spreadValues$f({}, q.q), {
+          joinedShapes: __spreadProps$9(__spreadValues$f(__spreadValues$f({}, query.joinedShapes), q.q.joinedShapes), {
             [table.q.as || table.table]: table.q.shape
           })
         }),
         joinAs
       );
       if (whereSql) {
-        if (conditions)
-          conditions += ` AND ${whereSql}`;
+        if (on)
+          on += ` AND ${whereSql}`;
         else
-          conditions = whereSql;
+          on = whereSql;
       }
     }
   }
-  return { target, conditions };
+  return { target, on };
 };
-const processArgs = (args, ctx, table, query, first, joinAs, joinShape, quotedAs) => {
-  var _a;
-  if (args.length === 1) {
-    const arg = args[0];
-    if (typeof arg === "function") {
-      const joinedShapes = __spreadProps$8(__spreadValues$e({}, query.joinedShapes), {
-        [table.q.as || table.table]: table.shape
-      });
-      let q;
-      let data;
-      if (typeof first === "string") {
-        const name = first;
-        const query2 = table.q;
-        const shape = (_a = query2.withShapes) == null ? void 0 : _a[name];
-        if (!shape) {
-          throw new Error("Cannot get shape of `with` statement");
-        }
-        q = Object.create(table);
-        q.q = {
-          type: void 0,
-          shape,
-          adapter: query2.adapter,
-          handleResult: query2.handleResult,
-          returnType: "all",
-          logger: query2.logger
-        };
-        data = { shape, joinedShapes };
-      } else {
-        q = first;
-        if (first.joinQueryAfterCallback) {
-          let base = q.baseQuery;
-          if (q.q.as) {
-            base = base.as(q.q.as);
-          }
-          const { q: query2 } = first.joinQueryAfterCallback(
-            base,
-            table
-          );
-          if (query2.and) {
-            pushQueryArray(q, "and", query2.and);
-          }
-          if (query2.or) {
-            pushQueryArray(q, "or", query2.or);
-          }
-        }
-        data = __spreadProps$8(__spreadValues$e({}, first.q), {
-          joinedShapes: __spreadValues$e(__spreadValues$e({}, first.q.joinedShapes), joinedShapes)
-        });
-      }
-      const jq = arg(new ctx.queryBuilder.onQueryBuilder(q, data, table));
-      if (jq.q.joinedShapes !== joinedShapes) {
-        jq.q.joinedShapes = __spreadValues$e(__spreadValues$e({}, jq.q.joinedShapes), joinedShapes);
-      }
-      return whereToSql(ctx, jq, jq.q, joinAs);
-    } else {
-      return getObjectOrRawConditions(
-        ctx,
-        query,
-        arg,
-        quotedAs,
-        joinAs,
-        joinShape
-      );
+const getArgQueryTarget = (ctx, first, joinSubQuery, cloned) => {
+  const joinQuery = first.q;
+  const quotedFrom = typeof joinQuery.from === "string" ? `"${joinQuery.from}"` : void 0;
+  let joinAs = quotedFrom || `"${first.table}"`;
+  const qAs = joinQuery.as ? `"${joinQuery.as}"` : void 0;
+  const addAs = qAs && qAs !== joinAs;
+  if (joinSubQuery) {
+    return {
+      target: subJoinToSql(ctx, first, joinAs, qAs, cloned),
+      joinAs: addAs ? qAs : joinAs
+    };
+  } else {
+    let target = quotedFrom || quoteSchemaAndTable(joinQuery.schema, first.table);
+    if (addAs) {
+      joinAs = qAs;
+      target += ` AS ${qAs}`;
     }
-  } else if (args.length >= 2) {
+    return { target, joinAs };
+  }
+};
+const subJoinToSql = (ctx, jq, innerAs, outerAs, cloned) => {
+  if (!jq.q.select && jq.internal.columnsForSelectAll) {
+    if (!cloned)
+      jq = jq.clone();
+    jq.q.select = [new RawSQL(`${innerAs}.*`)];
+  }
+  return `(${jq.toSQL({
+    values: ctx.values
+  }).text}) ${outerAs || innerAs}`;
+};
+const processArgs = (args, ctx, query, joinAs, joinShape, quotedAs) => {
+  if (args.length === 1) {
+    return getObjectOrRawConditions(
+      ctx,
+      query,
+      args[0],
+      quotedAs,
+      joinAs,
+      joinShape
+    );
+  } else {
     return getConditionsFor3Or4LengthItem(
       ctx,
       query,
@@ -1284,7 +1238,6 @@ const processArgs = (args, ctx, table, query, first, joinAs, joinShape, quotedAs
       joinShape
     );
   }
-  return void 0;
 };
 const getConditionsFor3Or4LengthItem = (ctx, query, target, quotedAs, args, joinShape) => {
   const [leftColumn, opOrRightColumn, maybeRightColumn] = args;
@@ -1334,14 +1287,14 @@ const pushJoinSql = (ctx, table, query, quotedAs) => {
       sql = `${item[0]} LATERAL (${q.toSQL(ctx).text}) "${((_a = query.joinOverrides) == null ? void 0 : _a[as]) || as}" ON true`;
       ctx.aliasValue = aliasValue;
     } else {
-      const { target, conditions } = processJoinItem(
+      const { target, on = "true" } = processJoinItem(
         ctx,
         table,
         query,
-        item,
+        item.args,
         quotedAs
       );
-      sql = conditions ? `${item.type} ${target} ON ${conditions}` : `${item.type} ${target} ON true`;
+      sql = `${item.type} ${target} ON ${on}`;
     }
     if (joinSet) {
       if (joinSet.has(sql))
@@ -1362,15 +1315,123 @@ const skipQueryKeysForSubQuery = {
   joinedShapes: true,
   returnsOne: true
 };
-const getIsJoinSubQuery = (query, baseQuery) => {
-  for (const key in query) {
-    if (!skipQueryKeysForSubQuery[key] && query[key] !== baseQuery[key]) {
+const getIsJoinSubQuery = (query) => {
+  const {
+    q,
+    baseQuery: { q: baseQ }
+  } = query;
+  for (const key in q) {
+    if (!skipQueryKeysForSubQuery[key] && q[key] !== baseQ[key]) {
       return true;
     }
   }
   return false;
 };
 
+var __defProp$e = Object.defineProperty;
+var __defProps$8 = Object.defineProperties;
+var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
+var __hasOwnProp$f = Object.prototype.hasOwnProperty;
+var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$e = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$f.call(b, prop))
+      __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(b)) {
+      if (__propIsEnum$f.call(b, prop))
+        __defNormalProp$e(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
+const processJoinArgs = (joinTo, first, args, joinSubQuery) => {
+  var _a;
+  if (typeof first === "string") {
+    if (first in joinTo.relations) {
+      const { query: toQuery, joinQuery } = joinTo.relations[first].relationConfig;
+      const j = joinQuery(toQuery, joinTo);
+      if (typeof args[0] === "function") {
+        const r = args[0](
+          makeJoinQueryBuilder(j, j.q.joinedShapes, joinTo)
+        );
+        return { j: j.merge(r), s: joinSubQuery || getIsJoinSubQuery(r), r };
+      }
+      return { j, s: joinSubQuery };
+    } else if (typeof args[0] !== "function") {
+      return { w: first, a: args };
+    } else {
+      const joinToQ = joinTo.q;
+      const shape = (_a = joinToQ.withShapes) == null ? void 0 : _a[first];
+      if (!shape) {
+        throw new Error("Cannot get shape of `with` statement");
+      }
+      const j = joinTo.queryBuilder.baseQuery.clone();
+      j.table = first;
+      j.q = {
+        shape,
+        adapter: joinToQ.adapter,
+        handleResult: joinToQ.handleResult,
+        returnType: "all",
+        logger: joinToQ.logger
+      };
+      j.baseQuery = j;
+      const joinedShapes = __spreadProps$8(__spreadValues$e({}, joinToQ.joinedShapes), {
+        [joinToQ.as || joinTo.table]: joinTo.shape
+      });
+      const r = args[0](
+        makeJoinQueryBuilder(
+          j,
+          j.q.joinedShapes ? __spreadValues$e(__spreadValues$e({}, j.q.joinedShapes), joinedShapes) : joinedShapes,
+          joinTo
+        )
+      );
+      return { w: first, r, s: joinSubQuery || getIsJoinSubQuery(r) };
+    }
+  } else if (typeof args[0] === "function") {
+    const q = first;
+    if (q.joinQueryAfterCallback) {
+      let base = q.baseQuery;
+      if (q.q.as) {
+        base = base.as(q.q.as);
+      }
+      const { q: query } = q.joinQueryAfterCallback(base, joinTo);
+      if (query.and) {
+        pushQueryArray(q, "and", query.and);
+      }
+      if (query.or) {
+        pushQueryArray(q, "or", query.or);
+      }
+    }
+    const joinedShapes = __spreadProps$8(__spreadValues$e({}, joinTo.q.joinedShapes), {
+      [joinTo.q.as || joinTo.table]: joinTo.shape
+    });
+    const r = args[0](
+      makeJoinQueryBuilder(
+        q,
+        q.q.joinedShapes ? __spreadValues$e(__spreadValues$e({}, q.q.joinedShapes), joinedShapes) : joinedShapes,
+        joinTo
+      )
+    );
+    joinSubQuery || (joinSubQuery = getIsJoinSubQuery(r));
+    return { q: joinSubQuery ? q.merge(r) : q, r, s: joinSubQuery };
+  }
+  return {
+    q: first,
+    a: args,
+    s: joinSubQuery
+  };
+};
+const makeJoinQueryBuilder = (joinedQuery, joinedShapes, joinTo) => {
+  const q = joinedQuery.baseQuery.clone();
+  q.q.joinedShapes = joinedShapes;
+  q.baseQuery = q;
+  q.q.joinTo = joinTo;
+  return q;
+};
+
 var __defProp$d = Object.defineProperty;
 var __defProps$7 = Object.defineProperties;
 var __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;
@@ -1391,23 +1452,24 @@ var __spreadValues$d = (a, b) => {
 };
 var __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
 const _join = (q, require2, type, first, args) => {
-  var _a;
+  var _a, _b;
   let joinKey;
   let shape;
   let parsers;
-  let isSubQuery = false;
+  let joinSubQuery = false;
   if (typeof first === "function") {
     first = first(q.relations);
     first.joinQueryAfterCallback = first.joinQuery;
   }
   if (typeof first === "object") {
-    isSubQuery = getIsJoinSubQuery(first.q, first.baseQuery.q);
-    joinKey = first.q.as || first.table;
+    const q2 = first;
+    joinSubQuery = getIsJoinSubQuery(q2);
+    joinKey = q2.q.as || q2.table;
     if (joinKey) {
-      shape = getShapeFromSelect(first, isSubQuery);
-      parsers = first.q.parsers;
-      if (isSubQuery) {
-        first = first.clone();
+      shape = getShapeFromSelect(q2, joinSubQuery);
+      parsers = q2.q.parsers;
+      if (joinSubQuery) {
+        first = q2.clone();
         first.shape = shape;
       }
     }
@@ -1433,14 +1495,46 @@ const _join = (q, require2, type, first, args) => {
     }
   }
   if (joinKey) {
-    setQueryObjectValue(q, "joinedShapes", joinKey, shape);
-    setQueryObjectValue(q, "joinedParsers", joinKey, parsers);
+    setQueryObjectValue(
+      q,
+      "joinedShapes",
+      joinKey,
+      shape
+    );
+    setQueryObjectValue(
+      q,
+      "joinedParsers",
+      joinKey,
+      parsers
+    );
   }
-  return pushQueryValue(q, "join", {
-    type,
+  const joinArgs = processJoinArgs(
+    q,
     first,
     args,
-    isSubQuery
+    joinSubQuery
+  );
+  if (joinKey && "s" in joinArgs && joinArgs.s) {
+    const j = "j" in joinArgs ? (_b = joinArgs.r) != null ? _b : joinArgs.j : "r" in joinArgs ? joinArgs.r : joinArgs.q;
+    if (j.q.select || !j.internal.columnsForSelectAll) {
+      const shape2 = getShapeFromSelect(j, true);
+      setQueryObjectValue(
+        q,
+        "joinedShapes",
+        joinKey,
+        shape2
+      );
+      setQueryObjectValue(
+        q,
+        "joinedParsers",
+        joinKey,
+        j.q.parsers
+      );
+    }
+  }
+  return pushQueryValue(q, "join", {
+    type,
+    args: joinArgs
   });
 };
 const _joinLateral = (self, type, arg, cb, as) => {
@@ -1450,7 +1544,7 @@ const _joinLateral = (self, type, arg, cb, as) => {
   if (typeof arg === "string") {
     relation = q.relations[arg];
     if (relation) {
-      arg = relation.relationConfig.query;
+      arg = relation.relationConfig.query.clone();
     } else {
       const shape = (_a = q.q.withShapes) == null ? void 0 : _a[arg];
       if (shape) {
@@ -3286,7 +3380,7 @@ const processValue = (ctx, table, QueryClass, key, value, quotedAs) => {
 };
 
 const pushDeleteSql = (ctx, table, query, quotedAs) => {
-  var _a, _b, _c;
+  var _a, _b, _c, _d;
   const from = `"${table.table}"`;
   ctx.sql.push(`DELETE FROM ${from}`);
   if (from !== quotedAs) {
@@ -3294,28 +3388,40 @@ const pushDeleteSql = (ctx, table, query, quotedAs) => {
   }
   let conditions;
   if ((_a = query.join) == null ? void 0 : _a.length) {
-    const items = [];
+    const targets = [];
+    const ons = [];
     const joinSet = query.join.length > 1 ? /* @__PURE__ */ new Set() : null;
     for (const item of query.join) {
-      if (!Array.isArray(item)) {
-        const join = processJoinItem(ctx, table, query, item, quotedAs);
-        const key = `${join.target}${join.conditions}`;
+      if (Array.isArray(item)) {
+        const q = item[1];
+        const { aliasValue } = ctx;
+        ctx.aliasValue = true;
+        const as = item[2];
+        targets.push(
+          `LATERAL (${q.toSQL(ctx).text}) "${((_b = query.joinOverrides) == null ? void 0 : _b[as]) || as}"`
+        );
+        ctx.aliasValue = aliasValue;
+      } else {
+        const join = processJoinItem(ctx, table, query, item.args, quotedAs);
+        const key = `${join.target}${join.on}`;
         if (joinSet) {
           if (joinSet.has(key))
             continue;
           joinSet.add(key);
         }
-        items.push(join);
+        targets.push(join.target);
+        if (join.on)
+          ons.push(join.on);
       }
     }
-    if (items.length) {
-      ctx.sql.push(`USING ${items.map((item) => item.target).join(", ")}`);
-      conditions = items.map((item) => item.conditions).filter(Boolean).join(" AND ");
+    if (targets.length) {
+      ctx.sql.push(`USING ${targets.join(", ")}`);
     }
+    conditions = ons.join(" AND ");
   }
   pushWhereStatementSql(ctx, table, query, quotedAs);
-  if (conditions == null ? void 0 : conditions.length) {
-    if (((_b = query.and) == null ? void 0 : _b.length) || ((_c = query.or) == null ? void 0 : _c.length)) {
+  if (conditions) {
+    if (((_c = query.and) == null ? void 0 : _c.length) || ((_d = query.or) == null ? void 0 : _d.length)) {
       ctx.sql.push("AND", conditions);
     } else {
       ctx.sql.push("WHERE", conditions);
@@ -6881,1944 +6987,1996 @@ class QueryHooks {
   }
 }
 
-class QueryBase {
-  constructor() {
-    this.q = {};
-  }
+class Join {
   /**
-   * Clones the current query chain, useful for re-using partial query snippets in other queries without mutating the original.
+   * ## Select relation
    *
-   * Used under the hood, and not really needed on the app side.
-   */
-  clone() {
-    const cloned = Object.create(this.baseQuery);
-    cloned.q = getClonedQueryData(this.q);
-    return cloned;
-  }
-}
-
-const _queryWhere = (q, args) => {
-  return pushQueryArray(
-    q,
-    "and",
-    args
-  );
-};
-const _queryWhereSql = (q, args) => {
-  return pushQueryValue(
-    q,
-    "and",
-    sqlQueryArgsToExpression(args)
-  );
-};
-const _queryWhereNot = (q, args) => {
-  return pushQueryValue(q, "and", {
-    NOT: args
-  });
-};
-const _queryWhereNotSql = (q, args) => {
-  return pushQueryValue(q, "and", {
-    NOT: sqlQueryArgsToExpression(args)
-  });
-};
-const _queryOr = (q, args) => {
-  return pushQueryArray(
-    q,
-    "or",
-    args.map((item) => [item])
-  );
-};
-const _queryOrNot = (q, args) => {
-  return pushQueryArray(
-    q,
-    "or",
-    args.map((item) => [{ NOT: item }])
-  );
-};
-const _queryWhereIn = (q, and, arg, values, not) => {
-  let item;
-  if (values) {
-    if (Array.isArray(arg)) {
-      item = {
-        IN: {
-          columns: arg,
-          values
-        }
-      };
-    } else {
-      item = { [arg]: { in: values } };
-    }
-  } else {
-    item = {};
-    for (const key in arg) {
-      item[key] = { in: arg[key] };
-    }
-  }
-  if (not)
-    item = { NOT: item };
-  if (and) {
-    pushQueryValue(q, "and", item);
-  } else {
-    pushQueryValue(q, "or", [item]);
-  }
-  return q;
-};
-const existsArgs = (q, args) => {
-  let isSubQuery;
-  if (typeof q === "object") {
-    isSubQuery = getIsJoinSubQuery(q.q, q.baseQuery.q);
-    if (isSubQuery) {
-      q = q.clone();
-      q.shape = getShapeFromSelect(q, true);
-    }
-  } else {
-    isSubQuery = false;
-  }
-  return [
-    {
-      EXISTS: {
-        first: q,
-        args,
-        isSubQuery
-      }
-    }
-  ];
-};
-class Where {
-  /**
-   * Constructing `WHERE` conditions:
+   * Before joining a table, consider if selecting a relation is enough for your case:
    *
    * ```ts
-   * db.table.where({
-   *   // column of the current table
-   *   name: 'John',
-   *
-   *   // table name may be specified, it can be the name of a joined table
-   *   'table.lastName': 'Johnsonuk',
+   * // select users with profiles
+   * // result type is Array<{ name: string, profile: Profile }>
+   * await db.user.select('name', {
+   *   profile: (q) => q.profile,
+   * });
    *
-   *   // object with operators, see the "column operators" section to see a full list of them:
-   *   age: {
-   *     gt: 30,
-   *     lt: 70,
-   *   },
+   * // select posts with counts of comments, order by comments count
+   * // result type is Array<Post & { commentsCount: number }>
+   * await db.post
+   *   .select('*', {
+   *     commentsCount: (q) => q.comments.count(),
+   *   })
+   *   .order({
+   *     commentsCount: 'DESC',
+   *   });
    *
-   *   // where column equals to raw SQL
-   *   column: db.table.sql`sql expression`,
+   * // select authors with array of their book titles
+   * // result type is Array<Author & { books: string[] }>
+   * await db.author.select('*', {
+   *   books: (q) => q.books.pluck('title'),
    * });
    * ```
    *
-   * Multiple `where`s are joined with `AND`:
+   * Internally, such selects will use `LEFT JOIN LATERAL` to join a relation.
+   * If you're loading users with profiles (one-to-one relation), and some users don't have a profile, `profile` property will have `NULL` for such users.
+   * If you want to load only users that have profiles, and filter out the rest, add `.join()` method to the relation without arguments:
    *
    * ```ts
-   * db.table.where({ foo: 'foo' }).where({ bar: 'bar' });
-   * ```
+   * // load only users who have a profile
+   * await db.user.select('*', {
+   *   profile: (q) => q.profile.join(),
+   * });
    *
-   * ```sql
-   * SELECT * FROM table WHERE foo = 'foo' AND bar = 'bar'
+   * // load only users who have a specific profile
+   * await db.user.select('*', {
+   *   profile: (q) => q.profile.join().where({ age: { gt: 20 } }),
+   * });
    * ```
    *
-   * `undefined` values are ignored, so you can supply a partial object with conditions:
+   * You can also use this `.join()` method on the one-to-many relations, and records with empty array will be filtered out:
    *
    * ```ts
-   * type Params = {
-   *   // allow providing exact age, or lower or greater than
-   *   age?: number | { lt?: number; gt?: number };
-   * };
-   *
-   * const loadRecords = async (params: Params) => {
-   *   // this will load all records if params is an empty object
-   *   const records = await db.table.where(params);
-   * };
+   * // posts that have no tags won't be loaded
+   * // result type is Array<Post & { tags: Tag[] }>
+   * db.post.select('*', {
+   *   tags: (q) => q.tags.join(),
+   * });
    * ```
    *
-   * It supports a sub-query that is selecting a single value to compare it with a column:
+   * # Joins
    *
-   * ```ts
-   * db.table.where({
-   *   // compare `someColumn` in one table with the `column` value returned from another query.
-   *   someColumn: db.otherTable.where(...conditions).get('column'),
-   * });
-   * ```
+   * `join` methods allows to join other tables, relations by name, [with](/guide/advanced-queries#with) statements, sub queries.
    *
-   * `where` can accept other queries and merge their conditions:
+   * All the `join` methods accept the same arguments, but returning type is different because with `join` it's guaranteed to load joined table, and with `leftJoin` the joined table columns may be `NULL` when no matching record was found.
+   *
+   * For the following examples, imagine we have a `User` table with `id` and `name`, and `Message` table with `id`, `text`, messages belongs to user via `userId` column:
    *
    * ```ts
-   * const otherQuery = db.table.where({ name: 'John' });
+   * export class UserTable extends BaseTable {
+   *   readonly table = 'user';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     name: t.text(),
+   *   }));
    *
-   * db.table.where({ id: 1 }, otherQuery);
-   * // this will produce WHERE "table"."id" = 1 AND "table"."name' = 'John'
+   *   relations = {
+   *     messages: this.hasMany(() => MessageTable, {
+   *       primaryKey: 'id',
+   *       foreignKey: 'userId',
+   *     }),
+   *   };
+   * }
+   *
+   * export class MessageTable extends BaseTable {
+   *   readonly table = 'message';
+   *   columns = this.setColumns((t) => ({
+   *     id: t.identity().primaryKey(),
+   *     text: t.text(),
+   *     ...t.timestamps(),
+   *   }));
+   *
+   *   relations = {
+   *     user: this.belongsTo(() => UserTable, {
+   *       primaryKey: 'id',
+   *       foreignKey: 'userId',
+   *     }),
+   *   };
+   * }
    * ```
    *
-   * `where` supports raw SQL:
+   * ## join
    *
-   * ```ts
-   * db.table.where(db.table.sql`a = b`);
+   * `join` is a method for SQL `JOIN`, which is equivalent to `INNER JOIN`, `LEFT INNERT JOIN`.
    *
-   * // or
-   * import { raw } from 'orchid-orm';
+   * When no matching record is found, it will skip records of the main table.
    *
-   * db.table.where(raw`a = b`);
+   * When joining the same table with the same condition more than once, duplicated joins will be ignored:
+   *
+   * ```ts
+   * // joining a relation
+   * db.post.join('comments').join('comments');
+   *
+   * // joining a table with a condition
+   * db.post
+   *   .join('comments', 'comments.postId', 'post.id')
+   *   .join('comments', 'comments.postId', 'post.id');
    * ```
    *
-   * `where` can accept a callback with a specific query builder containing all "where" methods such as `where`, `orWhere`, `whereNot`, `whereIn`, `whereExists`:
+   * Both queries will produce SQL with only 1 join
    *
-   * ```ts
-   * db.table.where((q) =>
-   *   q
-   *     .where({ name: 'Name' })
-   *     .orWhere({ id: 1 }, { id: 2 })
-   *     .whereIn('letter', ['a', 'b', 'c'])
-   *     .whereExists(Message, 'authorId', 'id'),
-   * );
+   * ```sql
+   * SELECT * FROM post JOIN comments ON comments.postId = post.id
    * ```
    *
-   * `where` can accept multiple arguments, conditions are joined with `AND`:
+   * However, this is only possible if the join has no dynamic values:
    *
    * ```ts
-   * db.table.where(
-   *   { id: 1 },
-   *   db.table.where({ name: 'John' }),
-   *   db.table.sql`a = b`,
-   * );
+   * db.post
+   *   .join('comments', (q) => q.where({ rating: { gt: 5 } }))
+   *   .join('comments', (q) => q.where({ rating: { gt: 5 } }));
    * ```
    *
-   * ## where sub query
+   * Both joins above have the same `{ gt: 5 }`, but still, the `5` is a dynamic value and in this case joins will be duplicated,
+   * resulting in a database error.
    *
-   * `where` handles a special callback where you can query a relation to get some value and filter by that value.
+   * ### join relation
    *
-   * It is useful for a faceted search. For instance, posts have tags, and we want to find all posts that have all the given tags.
+   * When relations are defined between the tables, you can join them by a relation name.
+   * Joined table can be references from `where` and `select` by a relation name.
    *
    * ```ts
-   * const givenTags = ['typescript', 'node.js'];
+   * const result = await db.user
+   *   .join('messages')
+   *   // after joining a table, we can use it in `where` conditions:
+   *   .where({ 'messages.text': { startsWith: 'Hi' } })
+   *   .select(
+   *     'name', // name is User column, table name may be omitted
+   *     'messages.text', // text is the Message column, and the table name is required
+   *   );
    *
-   * const posts = await db.post.where(
-   *   (post) =>
-   *     post.tags // query tags of the post
-   *       .whereIn('tagName', givenTags) // where name of the tag is inside array
-   *       .count() // count how many such tags were found
-   *       .equals(wantedTags.length), // the count must be exactly the length of array
-   *   // if the post has ony `typescript` tag but not the `node.js` it will be omitted
-   * );
+   * // result has the following type:
+   * const ok: { name: string; text: string }[] = result;
    * ```
    *
-   * This will produce an efficient SQL query:
+   * The first argument can also be a callback, where instead of relation name as a string we're picking it as a property of `q`.
+   * In such a way, we can alias the relation with `as`, add `where` conditions, use other query methods.
    *
-   * ```sql
-   * SELECT * FROM "post"
-   * WHERE (
-   *   SELECT count(*) = 3
-   *   FROM "tag" AS "tags"
-   *   WHERE "tag"."tagName" IN ('typescript', 'node.js')
-   *     -- join tags to the post via "postTag" table
-   *     AND EXISTS (
-   *       SELECT 1 FROM "postTag"
-   *       WHERE "postTag"."postId" = "post"."id"
-   *         AND "postTag"."tagId" = "tag"."id"
-   *     )
-   * )
+   * ```ts
+   * const result = await db.user.join((q) =>
+   *   q.messages.as('m').where({ text: 'some text' }),
+   * );
    * ```
    *
-   * In the example above we use `count()`, you can also use any other aggregate method instead, such as `min`, `max`, `avg`.
+   * Optionally, you can pass a second callback argument, it makes `on` and `orOn` methods available.
    *
-   * The `count()` is chained with `equals` to check for a strict equality, any other operation is also allowed, such as `not`, `lt`, `gt`.
+   * But remember that when joining a relation, the relevant `ON` conditions are already handled automatically.
    *
-   * ## where special keys
+   * ```ts
+   * const result = await db.user.join(
+   *   (q) => q.messages.as('m'),
+   *   (q) =>
+   *     q
+   *       .on('text', 'name') // additionally, match message with user name
+   *       .where({ text: 'some text' }), // you can add `where` in a second callback as well.
+   * );
+   * ```
    *
-   * The object passed to `where` can contain special keys, each of the keys corresponds to its own method and takes the same value as the type of argument of the method.
+   * ### Selecting full joined records
    *
-   * For example:
+   * `select` supports selecting a full record of a previously joined table by passing a table name with `.*` at the end:
    *
    * ```ts
-   * db.table.where({
-   *   NOT: { key: 'value' },
-   *   OR: [{ name: 'a' }, { name: 'b' }],
-   *   IN: {
-   *     columns: ['id', 'name'],
-   *     values: [
-   *       [1, 'a'],
-   *       [2, 'b'],
-   *     ],
-   *   },
+   * const result = await db.book.join('author').select('title', {
+   *   author: 'author.*',
    * });
+   *
+   * // result has the following type:
+   * const ok: {
+   *   // title of the book
+   *   title: string;
+   *   // a full author record is included:
+   *   author: { id: number; name: string; updatedAt: Date; createdAt: Date };
+   * }[] = result;
    * ```
    *
-   * Using methods `whereNot`, `orWhere`, `whereIn` instead of this is a shorter and cleaner way, but in some cases, such object keys way may be more convenient.
+   * It works fine for `1:1` (`belongsTo`, `hasOne`) relations, but it may have an unexpected result for `1:M` or `M:M` (`hasMany`, `hasAndBelongsToMany`) relations.
+   * For any kind of relation, it results in one main table record with data of exactly one joined table record, i.e. when selecting in this way, the records **won't** be collected into arrays.
    *
    * ```ts
-   * db.table.where({
-   *   // see .whereNot
-   *   NOT: { id: 1 },
-   *   // can be an array:
-   *   NOT: [{ id: 1 }, { id: 2 }],
-   *
-   *   // see .orWhere
-   *   OR: [{ name: 'a' }, { name: 'b' }],
-   *   // can be an array:
-   *   // this will give id = 1 AND id = 2 OR id = 3 AND id = 4
-   *   OR: [
-   *     [{ id: 1 }, { id: 2 }],
-   *     [{ id: 3 }, { id: 4 }],
-   *   ],
+   * const result = await db.user
+   *   .join('messages')
+   *   .where({ 'messages.text': { startsWith: 'Hi' } })
+   *   .select('name', { messages: 'messages.*' });
    *
-   *   // see .in, the key syntax requires an object with columns and values
-   *   IN: {
-   *     columns: ['id', 'name'],
-   *     values: [
-   *       [1, 'a'],
-   *       [2, 'b'],
-   *     ],
-   *   },
-   *   // can be an array:
-   *   IN: [
-   *     {
-   *       columns: ['id', 'name'],
-   *       values: [
-   *         [1, 'a'],
-   *         [2, 'b'],
-   *       ],
-   *     },
-   *     { columns: ['someColumn'], values: [['foo', 'bar']] },
-   *   ],
-   * });
+   * // result has the following type:
+   * const ok: {
+   *   name: string;
+   *   // full message is included:
+   *   messages: { id: number; text: string; updatedAt: Date; createdAt: Date };
+   * }[] = result;
    * ```
    *
-   * ## column operators
+   * Because it's a one-to-many relation, one user has many messages, the user data will be duplicated for different messages data:
    *
-   * `where` argument can take an object where the key is the name of the operator and the value is its argument.
+   * | name   | msg                            |
+   * | ------ | ------------------------------ |
+   * | user 1 | `{ id: 1, text: 'message 1' }` |
+   * | user 1 | `{ id: 2, text: 'message 2' }` |
+   * | user 1 | `{ id: 3, text: 'message 3' }` |
    *
-   * Different types of columns support different sets of operators.
+   * ### join table
    *
-   * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
+   * If relation wasn't defined, provide a `db.table` instance and specify columns for the join.
+   * Joined table can be references from `where` and `select` by a table name.
    *
    * ```ts
-   * import { sql } from 'orchid-orm';
-   *
-   * db.table.where({
-   *   numericColumn: {
-   *     // lower than 5
-   *     lt: 5,
-   *
-   *     // lower than the value returned by sub-query
-   *     lt: OtherTable.select('someNumber').take(),
-   *
-   *     // raw SQL expression produces WHERE "numericColumn" < "otherColumn" + 10
-   *     lt: sql`"otherColumn" + 10`,
-   *   },
-   * });
+   * // Join message where userId = id:
+   * db.user
+   *   .join(db.message, 'userId', 'id')
+   *   .where({ 'message.text': { startsWith: 'Hi' } })
+   *   .select('name', 'message.text');
    * ```
    *
-   * ### Any type of column operators
-   *
-   * `equals` is a simple `=` operator, it may be useful for comparing column value with JSON object:
+   * Columns in the join list may be prefixed with table names for clarity:
    *
    * ```ts
-   * db.table.where({
-   *  // when searching for an exact same JSON value, this won't work:
-   *   jsonColumn: someObject,
-   *
-   *   // use `{ equals: ... }` instead:
-   *   jsonColumn: { equals: someObject },
-   * });
+   * db.user.join(db.message, 'message.userId', 'user.id');
    * ```
    *
-   * `not` is `!=` (aka `<>`) not equal operator:
+   * Joined table can have an alias for referencing it further:
    *
    * ```ts
-   * db.table.where({
-   *   anyColumn: { not: value },
-   * });
+   * db.user
+   *   .join(db.message.as('m'), 'message.userId', 'user.id')
+   *   .where({ 'm.text': { startsWith: 'Hi' } })
+   *   .select('name', 'm.text');
    * ```
    *
-   * `in` is for the `IN` operator to check if the column value is included in a list of values.
-   *
-   * Takes an array of the same type as a column, a sub-query that returns a list of values, or a raw SQL expression that returns a list.
+   * Joined table can be selected as an object as well as the relation join above:
    *
    * ```ts
-   * db.table.where({
-   *   column: {
-   *     in: ['a', 'b', 'c'],
-   *
-   *     // WHERE "column" IN (SELECT "column" FROM "otherTable")
-   *     in: OtherTable.select('column'),
+   * const result = await db.user
+   *   .join(db.message.as('m'), 'message.userId', 'user.id')
+   *   .where({ 'm.text': { startsWith: 'Hi' } })
+   *   .select('name', { msg: 'm.*' });
    *
-   *     in: db.table.sql`('a', 'b')`,
-   *   },
-   * });
+   * // result has the following type:
+   * const ok: {
+   *   name: string;
+   *   // full message is included as msg:
+   *   msg: { id: number; text: string; updatedAt: Date; createdAt: Date };
+   * }[] = result;
    * ```
    *
-   * `notIn` is for the `NOT IN` operator, and takes the same arguments as `in`
-   *
-   * ### Numeric, Date, and Time column operators
-   *
-   * To compare numbers, dates, and times.
-   *
-   * `lt` is for `<` (lower than)
-   *
-   * `lte` is for `<=` (lower than or equal)
-   *
-   * `gt` is for `>` (greater than)
-   *
-   * `gte` is for `>=` (greater than or equal)
+   * You can provide a custom comparison operator
    *
    * ```ts
-   * db.table.where({
-   *   numericColumn: {
-   *     gt: 5,
-   *     lt: 10,
-   *   },
+   * db.user.join(db.message, 'userId', '!=', 'id');
+   * ```
    *
-   *   date: {
-   *     lte: new Date(),
-   *   },
+   * Join can accept raw SQL for the `ON` part of join:
    *
-   *   time: {
-   *     gte: new Date(),
-   *   },
-   * });
+   * ```ts
+   * db.user.join(
+   *   db.message,
+   *   db.user.sql`lower("message"."text") = lower("user"."name")`,
+   * );
    * ```
    *
-   * `between` also works with numeric, dates, and time columns, it takes an array of two elements.
-   *
-   * Both elements can be of the same type as a column, a sub-query, or a raw SQL expression.
+   * Join can accept raw SQL instead of columns:
    *
    * ```ts
-   * db.table.where({
-   *   column: {
-   *     // simple values
-   *     between: [1, 10],
+   * db.user.join(
+   *   db.message,
+   *   db.user.sql`lower("message"."text")`,
+   *   db.user.sql`lower("user"."name")`,
+   * );
    *
-   *     // sub-query and raw SQL expression
-   *     between: [OtherTable.select('column').take(), db.table.sql`2 + 2`],
-   *   },
-   * });
+   * // with operator:
+   * db.user.join(
+   *   db.message,
+   *   db.user.sql`lower("message"."text")`,
+   *   '!=',
+   *   db.user.sql`lower("user"."name")`,
+   * );
    * ```
    *
-   * ### Text column operators
-   *
-   * For `text`, `char`, `varchar`, and `json` columns.
+   * To join based on multiple columns, you can provide an object where keys are joining table columns, and values are main table columns or a raw SQL:
    *
-   * `json` is stored as text, so it has text operators. Use the `jsonb` type for JSON operators.
+   * ```ts
+   * db.user.join(db.message, {
+   *   userId: 'id',
    *
-   * Takes a string, or sub-query returning string, or raw SQL expression as well as other operators.
+   *   // with table names:
+   *   'message.userId': 'user.id',
    *
-   * ```ts
-   * db.table.where({
-   *   textColumn: {
-   *     // WHERE "textColumn" LIKE '%string%'
-   *     contains: 'string',
-   *     // WHERE "textColumn" ILIKE '%string%'
-   *     containsInsensitive: 'string',
-   *     // WHERE "textColumn" LIKE 'string%'
-   *     startsWith: 'string',
-   *     // WHERE "textColumn" ILIKE 'string%'
-   *     startsWithInsensitive: 'string',
-   *     // WHERE "textColumn" LIKE '%string'
-   *     endsWith: 'string',
-   *     // WHERE "textColumn" ILIKE '%string'
-   *     endsWithInsensitive: 'string',
-   *   },
+   *   // value can be a raw SQL expression:
+   *   text: db.user.sql`lower("user"."name")`,
    * });
    * ```
    *
-   * ### JSONB column operators
-   *
-   * For the `jsonb` column, note that the `json` type has text operators instead.
-   *
-   * `jsonPath` operator: compare a column value under a given JSON path with the provided value.
-   *
-   * Value can be of any type to compare with JSON value, or it can be a sub-query or a raw SQL expression.
+   * Join all records without conditions by providing `true`:
    *
    * ```ts
-   * db.table.where({
-   *   jsonbColumn: {
-   *     jsonPath: [
-   *       '$.name', // first element is JSON path
-   *       '=', // second argument is comparison operator
-   *       'value', // third argument is a value to compare with
-   *     ],
-   *   },
-   * });
+   * db.user.join(db.message, true);
    * ```
    *
-   * `jsonSupersetOf`: check if the column value is a superset of provided value.
-   *
-   * For instance, it is true if the column has JSON `{ "a": 1, "b": 2 }` and provided value is `{ "a": 1 }`.
-   *
-   * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
+   * Join methods can accept a callback with a special query builder that has `on` and `orOn` methods for handling advanced cases:
    *
    * ```ts
-   * db.table.where({
-   *   jsonbColumn: {
-   *     jsonSupersetOf: { a: 1 },
-   *   },
-   * });
-   * ```
-   *
-   * `jsonSubsetOf`: check if the column value is a subset of provided value.
-   *
-   * For instance, it is true if the column has JSON `{ "a": 1 }` and provided value is `{ "a": 1, "b": 2 }`.
-   *
-   * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
-   *
-   * ```ts
-   * db.table.where({
-   *   jsonbColumn: {
-   *     jsonSupersetOf: { a: 1 },
-   *   },
-   * });
+   * db.user.join(
+   *   db.message,
+   *   (q) =>
+   *     q
+   *       // left column is the db.message column, right column is the db.user column
+   *       .on('userId', 'id')
+   *       // table names can be provided:
+   *       .on('message.userId', 'user.id')
+   *       // operator can be specified:
+   *       .on('userId', '!=', 'id')
+   *       // operator can be specified with table names as well:
+   *       .on('message.userId', '!=', 'user.id')
+   *       // `.orOn` takes the same arguments as `.on` and acts like `.or`:
+   *       .on('userId', 'id') // where message.userId = user.id
+   *       .orOn('text', 'name'), // or message.text = user.name
+   * );
    * ```
    *
-   * @param args - {@link WhereArgs}
-   */
-  where(...args) {
-    return _queryWhere(
-      this.clone(),
-      args
-    );
-  }
-  /**
-   * Use a custom SQL expression in `WHERE` statement:
+   * Column names in the where conditions are applied for the joined table, but you can specify a table name to add a condition for the main table.
    *
    * ```ts
-   * db.table.where`a = b`;
-   *
-   * // or
-   * db.table.where(db.table.sql`a = b`);
+   * db.user.join(db.message, (q) =>
+   *   q
+   *     .on('userId', 'id')
+   *     .where({
+   *       // not prefixed column name is for joined table:
+   *       text: { startsWith: 'hello' },
+   *       // specify a table name to set condition on the main table:
+   *       'user.name': 'Bob',
+   *     })
+   *     // id is a column of a joined table Message
+   *     .whereIn('id', [1, 2, 3])
+   *     // condition for id of a user
+   *     .whereIn('user.id', [4, 5, 6]),
+   * );
+   * ```
    *
-   * // or
-   * import { raw } from 'orchid-orm';
+   * The query above will generate the following SQL (simplified):
    *
-   * db.table.where(raw`a = b`);
+   * ```sql
+   * SELECT * FROM "user"
+   * JOIN "message"
+   *   ON "message"."userId" = "user"."id"
+   *  AND "message"."text" ILIKE 'hello%'
+   *  AND "user"."name" = 'Bob'
+   *  AND "message"."id" IN (1, 2, 3)
+   *  AND "user"."id" IN (4, 5, 6)
    * ```
    *
-   * @param args - SQL expression
-   */
-  whereSql(...args) {
-    return _queryWhereSql(
-      this.clone(),
-      args
-    );
-  }
-  /**
-   * `whereNot` takes the same argument as `where`,
-   * multiple conditions are combined with `AND`,
-   * the whole group of conditions is negated with `NOT`.
+   * The join argument can be a query with `select`, `where`, and other methods. In such case, it will be handled as a sub query:
    *
    * ```ts
-   * // find records of different colors than red
-   * db.table.whereNot({ color: 'red' });
-   * // WHERE NOT color = 'red'
-   * db.table.whereNot({ one: 1, two: 2 });
-   * // WHERE NOT (one = 1 AND two = 2)
+   * db.user.join(
+   *   db.message
+   *     .select('id', 'userId', 'text')
+   *     .where({ text: { startsWith: 'Hi' } })
+   *     .as('t'),
+   *   'userId',
+   *   'id',
+   * );
    * ```
    *
-   * @param args - {@link WhereArgs}
-   */
-  whereNot(...args) {
-    return _queryWhereNot(
-      this.clone(),
-      args
-    );
-  }
-  /**
-   * `whereNot` version accepting SQL expression:
+   * It will produce such SQL:
    *
-   * ```ts
-   * db.table.whereNot`sql expression`
+   * ```sql
+   * SELECT * FROM "user"
+   * JOIN (
+   *   SELECT "t"."id", "t"."userId", "t"."text"
+   *   FROM "message" AS "t"
+   * ) "t" ON "t"."userId" = "user"."id"
    * ```
    *
-   * @param args - SQL expression
-   */
-  whereNotSql(...args) {
-    return _queryWhereNotSql(this.clone(), args);
-  }
-  /**
-   * `orWhere` is accepting the same arguments as {@link where}, joining arguments with `OR`.
+   * ## implicit join lateral
    *
-   * Columns in single arguments are still joined with `AND`.
+   * `JOIN`'s source expression that comes before `ON` cannot access other tables, but in some cases this may be needed.
    *
-   * The database is processing `AND` before `OR`, so this should be intuitively clear.
+   * For example, let's consider joining last 10 messages of a user:
    *
    * ```ts
-   * db.table.where({ id: 1, color: 'red' }).orWhere({ id: 2, color: 'blue' });
-   * // equivalent:
-   * db.table.orWhere({ id: 1, color: 'red' }, { id: 2, color: 'blue' });
+   * await db.user.join('messages', (q) => q.order({ createdAt: 'DESC' }).limit(10));
    * ```
    *
-   * This query will produce such SQL (simplified):
+   * When the `join`'s callback returns a more complex query than the one that simply applies certain conditions,
+   * it will implicitly generate a `JOIN LATERAL` SQL query, as the following:
    *
    * ```sql
-   * SELECT * FROM "table"
-   * WHERE id = 1 AND color = 'red'
-   *    OR id = 2 AND color = 'blue'
+   * SELECT *
+   * FROM "user"
+   * JOIN LATERAL (
+   *   SELECT *
+   *   FROM "message" AS "messages"
+   *   WHERE "message"."userId" = "user"."id"
+   *   ORDER BY "message"."createdAt" DESC
+   *   LIMIT 10
+   * ) "messages" ON true
    * ```
    *
-   * @param args - {@link WhereArgs} will be joined with `OR`
-   */
-  orWhere(...args) {
-    return _queryOr(this.clone(), args);
-  }
-  /**
-   * `orWhereNot` takes the same arguments as {@link orWhere}, and prepends each condition with `NOT` just as {@link whereNot} does.
-   *
-   * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
+   * @param arg - {@link JoinFirstArg}
+   * @param args - {@link JoinArgs}
    */
-  orWhereNot(...args) {
-    return _queryOrNot(
+  join(arg, ...args) {
+    return _join(
       this.clone(),
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+      true,
+      "JOIN",
+      arg,
       args
+      // eslint-disable-line @typescript-eslint/no-explicit-any
     );
   }
   /**
-   * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
-   *
-   * When used with a single column it works equivalent to the `in` column operator:
+   * `leftJoin` is a method for SQL `LEFT JOIN`, which is equivalent to `OUTER JOIN`, `LEFT OUTER JOIN`.
    *
-   * ```ts
-   * db.table.whereIn('column', [1, 2, 3]);
-   * // the same as:
-   * db.table.where({ column: [1, 2, 3] });
-   * ```
+   * When no matching record is found, it will fill joined table columns with `NULL` values in the result rows.
    *
-   * `whereIn` can support a tuple of columns, that's what the `in` operator cannot support:
+   * Works just like `join`, except for result type that may have `null`:
    *
    * ```ts
-   * db.table.whereIn(
-   *   ['id', 'name'],
-   *   [
-   *     [1, 'Alice'],
-   *     [2, 'Bob'],
-   *   ],
-   * );
-   * ```
+   * const result = await db.user
+   *   .leftJoin('messages')
+   *   .select('name', 'messages.text');
    *
-   * It supports sub query which should return records with columns of the same type:
+   * // the same query, but joining table explicitly
+   * const result2: typeof result = await db.user
+   *   .leftJoin(db.message, 'userId', 'id')
+   *   .select('name', 'message.text');
    *
-   * ```ts
-   * db.table.whereIn(['id', 'name'], OtherTable.select('id', 'name'));
+   * // result has the following type:
+   * const ok: { name: string; text: string | null }[] = result;
    * ```
    *
-   * It supports raw SQL expression:
-   *
-   * ```ts
-   * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
-   * ```
+   * @param arg - {@link JoinFirstArg}
+   * @param args - {@link JoinArgs}
    */
-  whereIn(...args) {
-    return _queryWhereIn(
+  leftJoin(arg, ...args) {
+    return _join(
       this.clone(),
-      true,
-      args[0],
-      args[1]
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+      false,
+      "LEFT JOIN",
+      arg,
+      args
+      // eslint-disable-line @typescript-eslint/no-explicit-any
     );
   }
   /**
-   * Takes the same arguments as {@link whereIn}.
-   * Add a `WHERE IN` condition prefixed with `OR` to the query:
+   * `rightJoin` is a method for SQL `RIGHT JOIN`, which is equivalent to `RIGHT OUTER JOIN`.
+   *
+   * Takes the same arguments as `json`.
+   *
+   * It will load all records from the joining table, and fill the main table columns with `null` when no match is found.
+   *
+   * The columns of the table you're joining to are becoming nullable when using `rightJoin`.
    *
    * ```ts
-   * db.table.whereIn('a', [1, 2, 3]).orWhereIn('b', ['one', 'two']);
+   * const result = await db.user
+   *   .rightJoin('messages')
+   *   .select('name', 'messages.text');
+   *
+   * // even though name is not a nullable column, it becomes nullable after using rightJoin
+   * const ok: { name: string | null; text: string }[] = result;
    * ```
+   *
+   * @param arg - {@link JoinFirstArg}
+   * @param args - {@link JoinArgs}
    */
-  orWhereIn(...args) {
-    return _queryWhereIn(
+  rightJoin(arg, ...args) {
+    return _join(
       this.clone(),
-      false,
-      args[0],
-      args[1]
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+      true,
+      "RIGHT JOIN",
+      arg,
+      args
+      // eslint-disable-line @typescript-eslint/no-explicit-any
     );
   }
   /**
-   * Acts as `whereIn`, but negates the condition with `NOT`:
+   * `fullJoin` is a method for SQL `FULL JOIN`, which is equivalent to `FULL OUTER JOIN`.
+   *
+   * Takes the same arguments as `json`.
+   *
+   * It will load all records from the joining table, both sides of the join may result in `null` values when there is no match.
+   *
+   * All columns become nullable after using `fullJoin`.
    *
    * ```ts
-   * db.table.whereNotIn('color', ['red', 'green', 'blue']);
+   * const result = await db.user
+   *   .rightJoin('messages')
+   *   .select('name', 'messages.text');
+   *
+   * // all columns can be null
+   * const ok: { name: string | null; text: string | null }[] = result;
    * ```
+   *
+   * @param arg - {@link JoinFirstArg}
+   * @param args - {@link JoinArgs}
    */
-  whereNotIn(...args) {
-    return _queryWhereIn(
+  fullJoin(arg, ...args) {
+    return _join(
       this.clone(),
-      true,
-      args[0],
-      args[1],
-      true
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+      false,
+      "FULL JOIN",
+      arg,
+      args
+      // eslint-disable-line @typescript-eslint/no-explicit-any
     );
   }
   /**
-   * Acts as `whereIn`, but prepends `OR` to the condition and negates it with `NOT`:
+   * `joinLateral` allows joining a table with a sub-query that can reference the main table of current query and the other joined tables.
    *
-   * ```ts
-   * db.table.whereNotIn('a', [1, 2, 3]).orWhereNoIn('b', ['one', 'two']);
-   * ```
-   */
-  orWhereNotIn(...args) {
-    return _queryWhereIn(
-      this.clone(),
-      false,
-      args[0],
-      args[1],
-      true
-    );
-  }
-  /**
-   * `whereExists` is for support of the `WHERE EXISTS (query)` clause.
+   * First argument is the other table you want to join, or a name of relation, or a name of `with` defined table.
    *
-   * This method is accepting the same arguments as `join`, see the {@link Join.join} section for more details.
+   * Second argument is a callback where you can reference other tables using `on` and `orOn`, select columns, do `where` conditions, and use any other query methods to build a sub-query.
+   *
+   * Note that the regular `join` will also generate `JOIN LATERAL` SQL expression when the query returned from callback is complex enough (see the bottom of {@link join} description).
    *
    * ```ts
-   * // find users who have accounts
-   * // find by a relation name if it's defined
-   * db.user.whereExists('account');
+   * // joinLateral a Message table, alias it as `m`
+   * // without aliasing you can refer to the message by a table name
+   * User.joinLateral(Message.as('m'), (q) =>
+   *   q
+   *     // select message columns
+   *     .select('text')
+   *     // join the message to the user, column names can be prefixed with table names
+   *     .on('authorId', 'id')
+   *     // message columns are available without prefixing,
+   *     // outer table columns are available with a table name
+   *     .where({ text: 'some text', 'user.name': 'name' })
+   *     .order({ createdAt: 'DESC' }),
+   * )
+   *   // only selected message columns are available in select and where
+   *   .select('id', 'name', 'm.text')
+   *   .where({ 'm.text': messageData.text });
+   * ```
    *
-   * // find using a table and a join conditions
-   * db.user.whereExists(db.account, 'account.id', 'user.id');
+   * As well as simple `join`, `joinLateral` can select an object of full joined record:
    *
-   * // find using a query builder in a callback:
-   * db.user.whereExists(db.account, (q) => q.on('account.id', '=', 'user.id'));
+   * ```ts
+   * // join by relation name
+   * const result = await User.joinLateral(
+   *   'messages',
+   *   (q) => q.as('message'), // alias to 'message'
+   * ).select('name', { message: 'message.*' });
+   *
+   * // result has the following type:
+   * const ok: {
+   *   name: string;
+   *   // full message is included:
+   *   message: { id: number; text: string; updatedAt: Date; createdAt: Date };
+   * }[] = result;
+   * ```
+   *
+   * `message` can be aliased withing the `select` as well as in case of a simple `join`:
+   *
+   * ```ts
+   * // join by relation name
+   * const result = await User.joinLateral(
+   *   'messages',
+   *   (q) => q.as('message'), // alias to 'message'
+   * ).select('name', { msg: 'message.*' });
+   *
+   * // result has the following type:
+   * const ok: {
+   *   name: string;
+   *   // full message is included as msg:
+   *   msg: { id: number; text: string; updatedAt: Date; createdAt: Date };
+   * }[] = result;
    * ```
+   *
+   * @param arg - {@link JoinFirstArg}
+   * @param cb - {@link JoinLateralCallback}
    */
-  whereExists(arg, ...args) {
-    return _queryWhere(
+  joinLateral(arg, cb) {
+    return _joinLateral(
       this.clone(),
-      existsArgs(arg, args)
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+      "JOIN",
+      arg,
+      cb
     );
   }
   /**
-   * Acts as `whereExists`, but prepends the condition with `OR`:
+   * The same as {@link joinLateral}, but when no records found for the join it will result in `null`:
    *
    * ```ts
-   * // find users who have an account or a profile,
-   * // imagine that the user has both `account` and `profile` relations defined.
-   * db.user.whereExist('account').orWhereExists('profile');
+   * const result = await db.user
+   *   .leftJoinLateral('messages', (q) => q.as('message'))
+   *   .select('name', 'message.text');
+   *
+   * // result has the following type:
+   * const ok: { name: string; text: string | null }[] = result;
    * ```
+   *
+   * @param arg - {@link JoinFirstArg}
+   * @param cb - {@link JoinLateralCallback}
    */
-  orWhereExists(arg, ...args) {
-    return _queryOr(
+  leftJoinLateral(arg, cb) {
+    return _joinLateral(
       this.clone(),
-      existsArgs(arg, args)
+      // eslint-disable-line @typescript-eslint/no-explicit-any
+      "LEFT JOIN",
+      arg,
+      cb
     );
   }
+}
+const makeOnItem = (joinTo, joinFrom, args) => {
+  return {
+    ON: {
+      joinTo,
+      joinFrom,
+      on: args
+    }
+  };
+};
+const pushQueryOn = (q, joinFrom, joinTo, ...on) => {
+  return pushQueryValue(
+    q,
+    "and",
+    makeOnItem(joinFrom, joinTo, on)
+  );
+};
+const pushQueryOrOn = (q, joinFrom, joinTo, ...on) => {
+  return pushQueryValue(q, "or", [
+    makeOnItem(joinFrom, joinTo, on)
+  ]);
+};
+const addQueryOn = (q, joinFrom, joinTo, ...args) => {
+  const cloned = q.clone();
+  setQueryObjectValue(
+    cloned,
+    "joinedShapes",
+    joinFrom.q.as || joinFrom.table,
+    joinFrom.q.shape
+  );
+  return pushQueryOn(cloned, joinFrom, joinTo, ...args);
+};
+const _queryJoinOn = (q, args) => {
+  return pushQueryOn(
+    q,
+    q.q.joinTo,
+    q,
+    ...args
+  );
+};
+const _queryJoinOrOn = (q, args) => {
+  return pushQueryOrOn(
+    q,
+    q.q.joinTo,
+    q,
+    ...args
+  );
+};
+const _queryJoinOnJsonPathEquals = (q, args) => {
+  return pushQueryValue(q, "and", {
+    ON: args
+  });
+};
+class OnMethods {
   /**
-   * Acts as `whereExists`, but negates the condition with `NOT`:
+   * Use `on` to specify columns to join records.
    *
    * ```ts
-   * // find users who don't have an account,
-   * // image that the user `belongsTo` or `hasOne` account.
-   * db.user.whereNotExist('account');
+   * q
+   *   // left column is the db.message column, right column is the db.user column
+   *   .on('userId', 'id')
+   *   // table names can be provided:
+   *   .on('message.userId', 'user.id')
+   *   // operator can be specified:
+   *   .on('userId', '!=', 'id')
+   *   // operator can be specified with table names as well:
+   *   .on('message.userId', '!=', 'user.id')
+   *   // `.orOn` takes the same arguments as `.on` and acts like `.or`:
+   *   .on('userId', 'id') // where message.userId = user.id
    * ```
    *
-   * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
-   * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
+   * @param args - columns to join with
    */
-  whereNotExists(arg, ...args) {
-    return _queryWhereNot(
-      this.clone(),
-      existsArgs(arg, args)
-    );
+  on(...args) {
+    return _queryJoinOn(this.clone(), args);
   }
   /**
-   * Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
+   * Works as {@link on}, but the added conditions will be separated from previous with `OR`.
+   *
+   * @param args - columns to join with
+   */
+  orOn(...args) {
+    return _queryJoinOrOn(this.clone(), args);
+  }
+  /**
+   * Use `onJsonPathEquals` to join record based on a field of their JSON column:
    *
    * ```ts
-   * // find users who don't have an account OR who don't have a profile
-   * // imagine that the user has both `account` and `profile` relations defined.
-   * db.user.whereNotExists('account').orWhereNotExists('profile');
+   * db.table.join(db.otherTable, (q) =>
+   *   // '$.key' is a JSON path
+   *   q.onJsonPathEquals('otherTable.data', '$.key', 'table.data', '$.key'),
+   * );
    * ```
+   *
+   * @param args - columns and JSON paths to join with.
    */
-  orWhereNotExists(arg, ...args) {
-    return _queryOrNot(
-      this.clone(),
-      existsArgs(arg, args)
-    );
+  onJsonPathEquals(...args) {
+    return _queryJoinOnJsonPathEquals(this.clone(), args);
   }
 }
-class WhereQueryBase extends QueryBase {
-}
-orchidCore.applyMixins(WhereQueryBase, [Where]);
 
-class Join {
+class JsonModifiers {
   /**
-   * ## Select relation
-   *
-   * Before joining a table, consider if selecting a relation is enough for your case:
-   *
-   * ```ts
-   * // select users with profiles
-   * // result type is Array<{ name: string, profile: Profile }>
-   * await db.user.select('name', {
-   *   profile: (q) => q.profile,
-   * });
-   *
-   * // select posts with counts of comments, order by comments count
-   * // result type is Array<Post & { commentsCount: number }>
-   * await db.post
-   *   .select('*', {
-   *     commentsCount: (q) => q.comments.count(),
-   *   })
-   *   .order({
-   *     commentsCount: 'DESC',
-   *   });
-   *
-   * // select authors with array of their book titles
-   * // result type is Array<Author & { books: string[] }>
-   * await db.author.select('*', {
-   *   books: (q) => q.books.pluck('title'),
-   * });
-   * ```
+   * Return a JSON value/object/array where a given value is set at the given path.
+   * The path is an array of keys to access the value.
    *
-   * Internally, such selects will use `LEFT JOIN LATERAL` to join a relation.
-   * If you're loading users with profiles (one-to-one relation), and some users don't have a profile, `profile` property will have `NULL` for such users.
-   * If you want to load only users that have profiles, and filter out the rest, add `.join()` method to the relation without arguments:
+   * Can be used in `update` callback.
    *
    * ```ts
-   * // load only users who have a profile
-   * await db.user.select('*', {
-   *   profile: (q) => q.profile.join(),
-   * });
+   * const result = await db.table.jsonSet('data', ['name'], 'new value').take();
    *
-   * // load only users who have a specific profile
-   * await db.user.select('*', {
-   *   profile: (q) => q.profile.join().where({ age: { gt: 20 } }),
-   * });
+   * expect(result.data).toEqual({ name: 'new value' });
    * ```
    *
-   * You can also use this `.join()` method on the one-to-many relations, and records with empty array will be filtered out:
+   * Optionally takes parameters of type `{ as?: string, createIfMissing?: boolean }`
    *
    * ```ts
-   * // posts that have no tags won't be loaded
-   * // result type is Array<Post & { tags: Tag[] }>
-   * db.post.select('*', {
-   *   tags: (q) => q.tags.join(),
+   * await db.table.jsonSet('data', ['name'], 'new value', {
+   *   as: 'alias', // select data as `alias`
+   *   createIfMissing: true, // ignored if missing by default
    * });
    * ```
    *
-   * # Joins
-   *
-   * `join` methods allows to join other tables, relations by name, [with](/guide/advanced-queries#with) statements, sub queries.
-   *
-   * All the `join` methods accept the same arguments, but returning type is different because with `join` it's guaranteed to load joined table, and with `leftJoin` the joined table columns may be `NULL` when no matching record was found.
-   *
-   * For the following examples, imagine we have a `User` table with `id` and `name`, and `Message` table with `id`, `text`, messages belongs to user via `userId` column:
-   *
-   * ```ts
-   * export class UserTable extends BaseTable {
-   *   readonly table = 'user';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     name: t.text(),
-   *   }));
+   * @param column - name of JSON column, or a result of a nested json method
+   * @param path - path to value inside the json
+   * @param value - value to set into the json
+   * @param options - `as` to alias the json value when selecting, `createIfMissing: true` will create a new JSON property if it didn't exist before
+   */
+  jsonSet(column, path, value, options) {
+    var _a;
+    const q = this.clone();
+    const json = {
+      __json: [
+        "set",
+        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
+        typeof column === "string" ? q.q.shape[column] : column.__json[2],
+        column,
+        path,
+        value,
+        options
+      ]
+    };
+    return Object.assign(
+      pushQueryValue(q, "select", json),
+      json
+    );
+  }
+  /**
+   * Return a JSON value/object/array where a given value is inserted at the given JSON path. Value can be a single value or JSON object. If a value exists at the given path, the value is not replaced.
    *
-   *   relations = {
-   *     messages: this.hasMany(() => MessageTable, {
-   *       primaryKey: 'id',
-   *       foreignKey: 'userId',
-   *     }),
-   *   };
-   * }
+   * Can be used in `update` callback.
    *
-   * export class MessageTable extends BaseTable {
-   *   readonly table = 'message';
-   *   columns = this.setColumns((t) => ({
-   *     id: t.identity().primaryKey(),
-   *     text: t.text(),
-   *     ...t.timestamps(),
-   *   }));
+   * ```ts
+   * // imagine user has data = { tags: ['two'] }
+   * const result = await db.table.jsonInsert('data', ['tags', 0], 'one').take();
    *
-   *   relations = {
-   *     user: this.belongsTo(() => UserTable, {
-   *       primaryKey: 'id',
-   *       foreignKey: 'userId',
-   *     }),
-   *   };
-   * }
+   * // 'one' is inserted to 0 position
+   * expect(result.data).toEqual({ tags: ['one', 'two'] });
    * ```
    *
-   * ## join
-   *
-   * `join` is a method for SQL `JOIN`, which is equivalent to `INNER JOIN`, `LEFT INNERT JOIN`.
-   *
-   * When no matching record is found, it will skip records of the main table.
-   *
-   * When joining the same table with the same condition more than once, duplicated joins will be ignored:
+   * Optionally takes parameters of type `{ as?: string, insertAfter?: boolean }`
    *
    * ```ts
-   * // joining a relation
-   * db.post.join('comments').join('comments');
-   *
-   * // joining a table with a condition
-   * db.post
-   *   .join('comments', 'comments.postId', 'post.id')
-   *   .join('comments', 'comments.postId', 'post.id');
-   * ```
-   *
-   * Both queries will produce SQL with only 1 join
+   * // imagine user has data = { tags: ['one'] }
+   * const result = await db.table
+   *   .jsonInsert('data', ['tags', 0], 'two', {
+   *     as: 'alias', // select as an alias
+   *     insertAfter: true, // insert after the specified position
+   *   })
+   *   .take();
    *
-   * ```sql
-   * SELECT * FROM post JOIN comments ON comments.postId = post.id
+   * // 'one' is inserted to 0 position
+   * expect(result.alias).toEqual({ tags: ['one', 'two'] });
    * ```
+   * @param column - name of JSON column, or a result of a nested json method
+   * @param path - path to the array inside the json, last path element is index to insert into
+   * @param value - value to insert into the json array
+   * @param options - `as` to alias the json value when selecting, `insertAfter: true` to insert after the specified position
+   */
+  jsonInsert(column, path, value, options) {
+    var _a;
+    const q = this.clone();
+    const json = {
+      __json: [
+        "insert",
+        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
+        typeof column === "string" ? q.q.shape[column] : column.__json[2],
+        column,
+        path,
+        value,
+        options
+      ]
+    };
+    return Object.assign(
+      pushQueryValue(q, "select", json),
+      json
+    );
+  }
+  /**
+   * Return a JSON value/object/array where a given value is removed at the given JSON path.
    *
-   * However, this is only possible if the join has no dynamic values:
+   * Can be used in `update` callback.
    *
    * ```ts
-   * db.post
-   *   .join('comments', (q) => q.where({ rating: { gt: 5 } }))
-   *   .join('comments', (q) => q.where({ rating: { gt: 5 } }));
-   * ```
-   *
-   * Both joins above have the same `{ gt: 5 }`, but still, the `5` is a dynamic value and in this case joins will be duplicated,
-   * resulting in a database error.
+   * // imagine a user has data = { tags: ['one', 'two'] }
+   * const result = await db.table
+   *   .jsonRemove(
+   *     'data',
+   *     ['tags', 0],
+   *     // optional parameters:
+   *     {
+   *       as: 'alias', // select as an alias
+   *     },
+   *   )
+   *   .take();
    *
-   * ### join relation
+   * expect(result.alias).toEqual({ tags: ['two'] });
+   * ```
    *
-   * When relations are defined between the tables, you can join them by a relation name.
-   * Joined table can be references from `where` and `select` by a relation name.
+   * @param column - name of JSON column, or a result of a nested json method
+   * @param path - path to the array inside the json, last path element is index to remove this element
+   * @param options - `as` to alias the json value when selecting
+   */
+  jsonRemove(column, path, options) {
+    var _a;
+    const q = this.clone();
+    const json = {
+      __json: [
+        "remove",
+        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
+        typeof column === "string" ? q.q.shape[column] : column.__json[2],
+        column,
+        path
+      ]
+    };
+    return Object.assign(
+      pushQueryValue(q, "select", json),
+      json
+    );
+  }
+  /**
+   * Selects a value from JSON data using a JSON path.
    *
    * ```ts
-   * const result = await db.user
-   *   .join('messages')
-   *   // after joining a table, we can use it in `where` conditions:
-   *   .where({ 'messages.text': { startsWith: 'Hi' } })
-   *   .select(
-   *     'name', // name is User column, table name may be omitted
-   *     'messages.text', // text is the Message column, and the table name is required
-   *   );
-   *
-   * // result has the following type:
-   * const ok: { name: string; text: string }[] = result;
-   * ```
+   * import { columnTypes } from 'orchid-orm';
    *
-   * The first argument can also be a callback, where instead of relation name as a string we're picking it as a property of `q`.
-   * In such a way, we can alias the relation with `as`, add `where` conditions, use other query methods.
+   * db.table.jsonPathQuery(
+   *   columnTypes.text(3, 100), // type of the value
+   *   'data', // name of the JSON column
+   *   '$.name', // JSON path
+   *   'name', // select value as name
    *
-   * ```ts
-   * const result = await db.user.join((q) =>
-   *   q.messages.as('m').where({ text: 'some text' }),
+   *   // Optionally supports `vars` and `silent` options
+   *   // check Postgres docs for jsonb_path_query for details
+   *   {
+   *     vars: 'vars',
+   *     silent: true,
+   *   },
    * );
    * ```
    *
-   * Optionally, you can pass a second callback argument, it makes `on` and `orOn` methods available.
-   *
-   * But remember that when joining a relation, the needed `ON` conditions are already handled automatically.
+   * Nested JSON operations can be used in place of JSON column name:
    *
    * ```ts
-   * const result = await db.user.join(
-   *   (q) => q.messages.as('m'),
-   *   (q) =>
-   *     q
-   *       .on('text', 'name') // additionally, match message with user name
-   *       .where({ text: 'some text' }), // you can add `where` in a second callback as well.
+   * db.table.jsonPathQuery(
+   *   columnTypes.text(3, 100),
+   *   // Available: .jsonSet, .jsonInsert, .jsonRemove
+   *   db.table.jsonSet('data', ['key'], 'value'),
+   *   '$.name',
+   *   'name',
    * );
    * ```
    *
-   * ### Selecting full joined records
-   *
-   * `select` supports selecting a full record of a previously joined table by passing a table name with `.*` at the end:
+   * @param type - provide a column type to have a correct result type
+   * @param column - name of JSON column, or a result of a nested json method
+   * @param path - special JSON path string to reference a JSON value
+   * @param as - optional alias for the selected value
+   * @param options - supports `vars` and `silent`, check Postgres docs of `json_path_query` for these
+   */
+  jsonPathQuery(type, column, path, as, options) {
+    const q = this.clone();
+    const json = {
+      __json: ["pathQuery", as, type, column, path, options]
+    };
+    return Object.assign(
+      pushQueryValue(q, "select", json),
+      json
+    );
+  }
+}
+class JsonMethods {
+  /**
+   * Wraps the query in a way to select a single JSON string.
+   * So that JSON encoding is done on a database side, and the application doesn't have to turn a response to a JSON.
+   * It may be better for performance in some cases.
    *
    * ```ts
-   * const result = await db.book.join('author').select('title', {
-   *   author: 'author.*',
-   * });
-   *
-   * // result has the following type:
-   * const ok: {
-   *   // title of the book
-   *   title: string;
-   *   // a full author record is included:
-   *   author: { id: number; name: string; updatedAt: Date; createdAt: Date };
-   * }[] = result;
+   * // json is a JSON string that you can directly send as a response.
+   * const json = await db.table.select('id', 'name').json();
    * ```
    *
-   * It works fine for `1:1` (`belongsTo`, `hasOne`) relations, but it may have an unexpected result for `1:M` or `M:M` (`hasMany`, `hasAndBelongsToMany`) relations.
-   * For any kind of relation, it results in one main table record with data of exactly one joined table record, i.e. when selecting in this way, the records **won't** be collected into arrays.
-   *
-   * ```ts
-   * const result = await db.user
-   *   .join('messages')
-   *   .where({ 'messages.text': { startsWith: 'Hi' } })
-   *   .select('name', { messages: 'messages.*' });
-   *
-   * // result has the following type:
-   * const ok: {
-   *   name: string;
-   *   // full message is included:
-   *   messages: { id: number; text: string; updatedAt: Date; createdAt: Date };
-   * }[] = result;
-   * ```
+   * @param coalesce
+   */
+  json(coalesce) {
+    return queryJson(
+      this.clone(),
+      coalesce
+    );
+  }
+}
+
+const logColors = {
+  boldCyanBright: (message) => `\x1B[1m\x1B[96m${message}\x1B[39m\x1B[22m`,
+  boldBlue: (message) => `\x1B[1m\x1B[34m${message}\x1B[39m\x1B[22m`,
+  boldYellow: (message) => `\x1B[1m\x1B[33m${message}\x1B[39m\x1B[22m`,
+  boldMagenta: (message) => `\x1B[1m\x1B[33m${message}\x1B[39m\x1B[22m`,
+  boldRed: (message) => `\x1B[1m\x1B[31m${message}\x1B[39m\x1B[22m`
+};
+const makeMessage = (colors, timeColor, time, sqlColor, sql, valuesColor, values) => {
+  const elapsed = process.hrtime(time);
+  const formattedTime = `(${elapsed[0] ? `${elapsed[0]}s ` : ""}${(elapsed[1] / 1e6).toFixed(1)}ms)`;
+  const result = `${colors ? timeColor(formattedTime) : formattedTime} ${colors ? sqlColor(sql) : sql}`;
+  if (!values.length) {
+    return result;
+  }
+  const formattedValues = `[${values.map(quote).join(", ")}]`;
+  return `${result} ${colors ? valuesColor(formattedValues) : formattedValues}`;
+};
+const logParamToLogObject = (logger, log) => {
+  if (!log)
+    return;
+  const logObject = Object.assign(
+    {
+      colors: true,
+      beforeQuery() {
+        return process.hrtime();
+      },
+      afterQuery(sql, time) {
+        logger.log(
+          makeMessage(
+            colors,
+            logColors.boldCyanBright,
+            time,
+            logColors.boldBlue,
+            sql.text,
+            logColors.boldYellow,
+            sql.values
+          )
+        );
+      },
+      onError(error, sql, time) {
+        const message = `Error: ${error.message}`;
+        logger.error(
+          `${makeMessage(
+            colors,
+            logColors.boldMagenta,
+            time,
+            logColors.boldRed,
+            sql.text,
+            logColors.boldYellow,
+            sql.values
+          )} ${colors ? logColors.boldRed(message) : message}`
+        );
+      }
+    },
+    log === true ? {} : log
+  );
+  const colors = logObject.colors;
+  return logObject;
+};
+class QueryLog {
+  log(log = true) {
+    const q = this.clone();
+    q.q.log = logParamToLogObject(q.q.logger, log);
+    return q;
+  }
+}
+
+var __defProp$5 = Object.defineProperty;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+const mergableObjects = {
+  shape: true,
+  withShapes: true,
+  parsers: true,
+  defaults: true,
+  joinedShapes: true,
+  joinedParsers: true
+};
+class MergeQueryMethods {
+  merge(q) {
+    const query = this.clone();
+    const a = query.q;
+    const b = q.q;
+    for (const key in b) {
+      const value = b[key];
+      switch (typeof value) {
+        case "boolean":
+        case "string":
+        case "number":
+          a[key] = value;
+          break;
+        case "object":
+          if (Array.isArray(value)) {
+            a[key] = a[key] ? [...a[key], ...value] : value;
+          } else if (mergableObjects[key]) {
+            a[key] = a[key] ? __spreadValues$5(__spreadValues$5({}, a[key]), value) : value;
+          } else {
+            a[key] = value;
+          }
+          break;
+      }
+    }
+    a[orchidCore.getValueKey] = b[orchidCore.getValueKey];
+    if (b.returnType)
+      a.returnType = b.returnType;
+    return query;
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+class With {
+  /**
+   * Add Common Table Expression (CTE) to the query.
    *
-   * Because it's a one-to-many relation, one user has many messages, the user data will be duplicated for different messages data:
+   * ```ts
+   * import { columnTypes } from 'orchid-orm';
+   * import { NumberColumn } from './number';
    *
-   * | name   | msg                            |
-   * | ------ | ------------------------------ |
-   * | user 1 | `{ id: 1, text: 'message 1' }` |
-   * | user 1 | `{ id: 2, text: 'message 2' }` |
-   * | user 1 | `{ id: 3, text: 'message 3' }` |
+   * // .with optionally accepts such options:
+   * type WithOptions = {
+   *   // list of columns returned by this WITH statement
+   *   // by default all columns from provided column shape will be included
+   *   // true is for default behavior
+   *   columns?: string[] | boolean;
    *
-   * ### join table
+   *   // Adds RECURSIVE keyword:
+   *   recursive?: true;
    *
-   * If relation wasn't defined, provide a `db.table` instance and specify columns for the join.
-   * Joined table can be references from `where` and `select` by a table name.
+   *   // Adds MATERIALIZED keyword:
+   *   materialized?: true;
+   *
+   *   // Adds NOT MATERIALIZED keyword:
+   *   notMaterialized?: true;
+   * };
+   *
+   * // accepts columns shape and a raw expression:
+   * db.table.with(
+   *   'alias',
+   *   {
+   *     id: columnTypes.integer(),
+   *     name: columnTypes.text(3, 100),
+   *   },
+   *   db.table.sql`SELECT id, name FROM "someTable"`,
+   * );
+   *
+   * // accepts query:
+   * db.table.with('alias', db.table.all());
+   *
+   * // accepts a callback for a query builder:
+   * db.table.with('alias', (qb) =>
+   *   qb.select({ one: db.table.sql((t) => t.integer())`1` }),
+   * );
+   *
+   * // All mentioned forms can accept options as a second argument:
+   * db.table.with(
+   *   'alias',
+   *   {
+   *     recursive: true,
+   *     materialized: true,
+   *   },
+   *   rawOrQueryOrCallback,
+   * );
+   * ```
+   *
+   * Defined `WITH` table can be used in `.from` or `.join` with all the type safeness:
    *
    * ```ts
-   * // Join message where userId = id:
-   * db.user
-   *   .join(db.message, 'userId', 'id')
-   *   .where({ 'message.text': { startsWith: 'Hi' } })
-   *   .select('name', 'message.text');
+   * db.table.with('alias', db.table.all()).from('alias').select('alias.id');
+   *
+   * db.table
+   *   .with('alias', db.table.all())
+   *   .join('alias', 'alias.id', 'user.id')
+   *   .select('alias.id');
    * ```
    *
-   * Columns in the join list may be prefixed with table names for clarity:
+   * @param args - first argument is an alias for this CTE, other arguments can be column shape, query object, or raw SQL.
+   */
+  with(...args) {
+    const q = this.clone();
+    let options = args.length === 3 && !orchidCore.isExpression(args[2]) || args.length === 4 ? args[1] : void 0;
+    const last = args[args.length - 1];
+    const query = typeof last === "function" ? last(q.queryBuilder) : last;
+    const shape = args.length === 4 ? args[2] : orchidCore.isExpression(query) ? args[1] : query.q.shape;
+    if ((options == null ? void 0 : options.columns) === true) {
+      options = __spreadProps$2(__spreadValues$4({}, options), {
+        columns: Object.keys(shape)
+      });
+    }
+    pushQueryValue(q, "with", [args[0], options || orchidCore.emptyObject, query]);
+    return setQueryObjectValue(q, "withShapes", args[0], shape);
+  }
+}
+
+class Union {
+  /**
+   * Creates a union query, taking an array or a list of callbacks, builders, or raw statements to build the union statement, with optional boolean `wrap`.
+   * If the `wrap` parameter is true, the queries will be individually wrapped in parentheses.
    *
    * ```ts
-   * db.user.join(db.message, 'message.userId', 'user.id');
+   * SomeTable.select('id', 'name').union(
+   *   [
+   *     OtherTable.select('id', 'name'),
+   *     SomeTable.sql`SELECT id, name FROM "thirdTable"`,
+   *   ],
+   *   true, // optional wrap parameter
+   * );
    * ```
    *
-   * Joined table can have an alias for referencing it further:
+   * @param args - array of queries or raw SQLs
+   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   */
+  union(args, wrap) {
+    return pushQueryArray(
+      this.clone(),
+      "union",
+      args.map((arg) => ({ arg, kind: "UNION", wrap }))
+    );
+  }
+  /**
+   * Same as `union`, but allows duplicated rows.
+   *
+   * @param args - array of queries or raw SQLs
+   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   */
+  unionAll(args, wrap) {
+    return pushQueryArray(
+      this.clone(),
+      "union",
+      args.map((arg) => ({ arg, kind: "UNION ALL", wrap }))
+    );
+  }
+  /**
+   * Same as `union`, but uses a `INTERSECT` SQL keyword instead
+   *
+   * @param args - array of queries or raw SQLs
+   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   */
+  intersect(args, wrap) {
+    return pushQueryArray(
+      this.clone(),
+      "union",
+      args.map((arg) => ({ arg, kind: "INTERSECT", wrap }))
+    );
+  }
+  /**
+   * Same as `intersect`, but allows duplicated rows.
+   *
+   * @param args - array of queries or raw SQLs
+   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   */
+  intersectAll(args, wrap) {
+    return pushQueryArray(
+      this.clone(),
+      "union",
+      args.map((arg) => ({ arg, kind: "INTERSECT ALL", wrap }))
+    );
+  }
+  /**
+   * Same as `union`, but uses an `EXCEPT` SQL keyword instead
+   *
+   * @param args - array of queries or raw SQLs
+   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   */
+  except(args, wrap) {
+    return pushQueryArray(
+      this.clone(),
+      "union",
+      args.map((arg) => ({ arg, kind: "EXCEPT", wrap }))
+    );
+  }
+  /**
+   * Same as `except`, but allows duplicated rows.
+   *
+   * @param args - array of queries or raw SQLs
+   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   */
+  exceptAll(args, wrap) {
+    return pushQueryArray(
+      this.clone(),
+      "union",
+      args.map((arg) => ({ arg, kind: "EXCEPT ALL", wrap }))
+    );
+  }
+}
+
+const _queryWhere = (q, args) => {
+  return pushQueryArray(
+    q,
+    "and",
+    args
+  );
+};
+const _queryWhereSql = (q, args) => {
+  return pushQueryValue(
+    q,
+    "and",
+    sqlQueryArgsToExpression(args)
+  );
+};
+const _queryWhereNot = (q, args) => {
+  return pushQueryValue(q, "and", {
+    NOT: args
+  });
+};
+const _queryWhereNotSql = (q, args) => {
+  return pushQueryValue(q, "and", {
+    NOT: sqlQueryArgsToExpression(args)
+  });
+};
+const _queryOr = (q, args) => {
+  return pushQueryArray(
+    q,
+    "or",
+    args.map((item) => [item])
+  );
+};
+const _queryOrNot = (q, args) => {
+  return pushQueryArray(
+    q,
+    "or",
+    args.map((item) => [{ NOT: item }])
+  );
+};
+const _queryWhereIn = (q, and, arg, values, not) => {
+  let item;
+  if (values) {
+    if (Array.isArray(arg)) {
+      item = {
+        IN: {
+          columns: arg,
+          values
+        }
+      };
+    } else {
+      item = { [arg]: { in: values } };
+    }
+  } else {
+    item = {};
+    for (const key in arg) {
+      item[key] = { in: arg[key] };
+    }
+  }
+  if (not)
+    item = { NOT: item };
+  if (and) {
+    pushQueryValue(q, "and", item);
+  } else {
+    pushQueryValue(q, "or", [item]);
+  }
+  return q;
+};
+const existsArgs = (self, q, args) => {
+  let joinSubQuery;
+  if (typeof q === "object") {
+    joinSubQuery = getIsJoinSubQuery(q);
+    if (joinSubQuery) {
+      q = q.clone();
+      q.shape = getShapeFromSelect(
+        q,
+        true
+      );
+    }
+  } else {
+    joinSubQuery = false;
+  }
+  const joinArgs = processJoinArgs(self, q, args, joinSubQuery);
+  return [
+    {
+      EXISTS: joinArgs
+    }
+  ];
+};
+const _queryWhereExists = (q, arg, args) => {
+  return _queryWhere(
+    q,
+    existsArgs(q, arg, args)
+  );
+};
+class Where {
+  /**
+   * Constructing `WHERE` conditions:
    *
    * ```ts
-   * db.user
-   *   .join(db.message.as('m'), 'message.userId', 'user.id')
-   *   .where({ 'm.text': { startsWith: 'Hi' } })
-   *   .select('name', 'm.text');
-   * ```
+   * db.table.where({
+   *   // column of the current table
+   *   name: 'John',
    *
-   * Joined table can be selected as an object as well as the relation join above:
+   *   // table name may be specified, it can be the name of a joined table
+   *   'table.lastName': 'Johnsonuk',
    *
-   * ```ts
-   * const result = await db.user
-   *   .join(db.message.as('m'), 'message.userId', 'user.id')
-   *   .where({ 'm.text': { startsWith: 'Hi' } })
-   *   .select('name', { msg: 'm.*' });
+   *   // object with operators, see the "column operators" section to see a full list of them:
+   *   age: {
+   *     gt: 30,
+   *     lt: 70,
+   *   },
    *
-   * // result has the following type:
-   * const ok: {
-   *   name: string;
-   *   // full message is included as msg:
-   *   msg: { id: number; text: string; updatedAt: Date; createdAt: Date };
-   * }[] = result;
+   *   // where column equals to raw SQL
+   *   column: db.table.sql`sql expression`,
+   * });
    * ```
    *
-   * You can provide a custom comparison operator
+   * Multiple `where`s are joined with `AND`:
    *
    * ```ts
-   * db.user.join(db.message, 'userId', '!=', 'id');
+   * db.table.where({ foo: 'foo' }).where({ bar: 'bar' });
    * ```
    *
-   * Join can accept raw SQL for the `ON` part of join:
-   *
-   * ```ts
-   * db.user.join(
-   *   db.message,
-   *   db.user.sql`lower("message"."text") = lower("user"."name")`,
-   * );
+   * ```sql
+   * SELECT * FROM table WHERE foo = 'foo' AND bar = 'bar'
    * ```
    *
-   * Join can accept raw SQL instead of columns:
+   * `undefined` values are ignored, so you can supply a partial object with conditions:
    *
    * ```ts
-   * db.user.join(
-   *   db.message,
-   *   db.user.sql`lower("message"."text")`,
-   *   db.user.sql`lower("user"."name")`,
-   * );
+   * type Params = {
+   *   // allow providing exact age, or lower or greater than
+   *   age?: number | { lt?: number; gt?: number };
+   * };
    *
-   * // with operator:
-   * db.user.join(
-   *   db.message,
-   *   db.user.sql`lower("message"."text")`,
-   *   '!=',
-   *   db.user.sql`lower("user"."name")`,
-   * );
+   * const loadRecords = async (params: Params) => {
+   *   // this will load all records if params is an empty object
+   *   const records = await db.table.where(params);
+   * };
    * ```
    *
-   * To join based on multiple columns, you can provide an object where keys are joining table columns, and values are main table columns or a raw SQL:
+   * It supports a sub-query that is selecting a single value to compare it with a column:
    *
    * ```ts
-   * db.user.join(db.message, {
-   *   userId: 'id',
-   *
-   *   // with table names:
-   *   'message.userId': 'user.id',
-   *
-   *   // value can be a raw SQL expression:
-   *   text: db.user.sql`lower("user"."name")`,
+   * db.table.where({
+   *   // compare `someColumn` in one table with the `column` value returned from another query.
+   *   someColumn: db.otherTable.where(...conditions).get('column'),
    * });
    * ```
    *
-   * Join all records without conditions by providing `true`:
-   *
-   * ```ts
-   * db.user.join(db.message, true);
-   * ```
-   *
-   * Join methods can accept a callback with a special query builder that has `on` and `orOn` methods for handling advanced cases:
-   *
-   * ```ts
-   * db.user.join(
-   *   db.message,
-   *   (q) =>
-   *     q
-   *       // left column is the db.message column, right column is the db.user column
-   *       .on('userId', 'id')
-   *       // table names can be provided:
-   *       .on('message.userId', 'user.id')
-   *       // operator can be specified:
-   *       .on('userId', '!=', 'id')
-   *       // operator can be specified with table names as well:
-   *       .on('message.userId', '!=', 'user.id')
-   *       // `.orOn` takes the same arguments as `.on` and acts like `.or`:
-   *       .on('userId', 'id') // where message.userId = user.id
-   *       .orOn('text', 'name'), // or message.text = user.name
-   * );
-   * ```
-   *
-   * Join query builder supports all `where` methods: `.where`, `.whereIn`, `.whereExists`, and all `.or`, `.not`, and `.orNot` forms.
-   *
-   * Column names in the where conditions are applied for the joined table, but you can specify a table name to add a condition for the main table.
-   *
-   * ```ts
-   * db.user.join(db.message, (q) =>
-   *   q
-   *     .on('userId', 'id')
-   *     .where({
-   *       // not prefixed column name is for joined table:
-   *       text: { startsWith: 'hello' },
-   *       // specify a table name to set condition on the main table:
-   *       'user.name': 'Bob',
-   *     })
-   *     // id is a column of a joined table Message
-   *     .whereIn('id', [1, 2, 3])
-   *     // condition for id of a user
-   *     .whereIn('user.id', [4, 5, 6]),
-   * );
-   * ```
-   *
-   * The query above will generate the following SQL (simplified):
-   *
-   * ```sql
-   * SELECT * FROM "user"
-   * JOIN "message"
-   *   ON "message"."userId" = "user"."id"
-   *  AND "message"."text" ILIKE 'hello%'
-   *  AND "user"."name" = 'Bob'
-   *  AND "message"."id" IN (1, 2, 3)
-   *  AND "user"."id" IN (4, 5, 6)
-   * ```
-   *
-   * The join argument can be a query with `select`, `where`, and other methods. In such case, it will be handled as a sub query:
+   * `where` can accept other queries and merge their conditions:
    *
    * ```ts
-   * db.user.join(
-   *   db.message
-   *     .select('id', 'userId', 'text')
-   *     .where({ text: { startsWith: 'Hi' } })
-   *     .as('t'),
-   *   'userId',
-   *   'id',
-   * );
-   * ```
-   *
-   * It will produce such SQL:
+   * const otherQuery = db.table.where({ name: 'John' });
    *
-   * ```sql
-   * SELECT * FROM "user"
-   * JOIN (
-   *   SELECT "t"."id", "t"."userId", "t"."text"
-   *   FROM "message" AS "t"
-   * ) "t" ON "t"."userId" = "user"."id"
+   * db.table.where({ id: 1 }, otherQuery);
+   * // this will produce WHERE "table"."id" = 1 AND "table"."name' = 'John'
    * ```
    *
-   * @param arg - {@link JoinFirstArg}
-   * @param args - {@link JoinArgs}
-   */
-  join(arg, ...args) {
-    return _join(this.clone(), true, "JOIN", arg, args);
-  }
-  /**
-   * `leftJoin` is a method for SQL `LEFT JOIN`, which is equivalent to `OUTER JOIN`, `LEFT OUTER JOIN`.
-   *
-   * When no matching record is found, it will fill joined table columns with `NULL` values in the result rows.
-   *
-   * Works just like `join`, except for result type that may have `null`:
+   * `where` supports raw SQL:
    *
    * ```ts
-   * const result = await db.user
-   *   .leftJoin('messages')
-   *   .select('name', 'messages.text');
-   *
-   * // the same query, but joining table explicitly
-   * const result2: typeof result = await db.user
-   *   .leftJoin(db.message, 'userId', 'id')
-   *   .select('name', 'message.text');
-   *
-   * // result has the following type:
-   * const ok: { name: string; text: string | null }[] = result;
-   * ```
-   *
-   * @param arg - {@link JoinFirstArg}
-   * @param args - {@link JoinArgs}
-   */
-  leftJoin(arg, ...args) {
-    return _join(this.clone(), false, "LEFT JOIN", arg, args);
-  }
-  /**
-   * `rightJoin` is a method for SQL `RIGHT JOIN`, which is equivalent to `RIGHT OUTER JOIN`.
+   * db.table.where(db.table.sql`a = b`);
    *
-   * Takes the same arguments as `json`.
+   * // or
+   * import { raw } from 'orchid-orm';
    *
-   * It will load all records from the joining table, and fill the main table columns with `null` when no match is found.
+   * db.table.where(raw`a = b`);
+   * ```
    *
-   * The columns of the table you're joining to are becoming nullable when using `rightJoin`.
+   * `where` can accept a callback with a specific query builder containing all "where" methods such as `where`, `orWhere`, `whereNot`, `whereIn`, `whereExists`:
    *
    * ```ts
-   * const result = await db.user
-   *   .rightJoin('messages')
-   *   .select('name', 'messages.text');
-   *
-   * // even though name is not a nullable column, it becomes nullable after using rightJoin
-   * const ok: { name: string | null; text: string }[] = result;
+   * db.table.where((q) =>
+   *   q
+   *     .where({ name: 'Name' })
+   *     .orWhere({ id: 1 }, { id: 2 })
+   *     .whereIn('letter', ['a', 'b', 'c'])
+   *     .whereExists(Message, 'authorId', 'id'),
+   * );
    * ```
    *
-   * @param arg - {@link JoinFirstArg}
-   * @param args - {@link JoinArgs}
-   */
-  rightJoin(arg, ...args) {
-    return _join(this.clone(), true, "RIGHT JOIN", arg, args);
-  }
-  /**
-   * `fullJoin` is a method for SQL `FULL JOIN`, which is equivalent to `FULL OUTER JOIN`.
+   * `where` can accept multiple arguments, conditions are joined with `AND`:
    *
-   * Takes the same arguments as `json`.
+   * ```ts
+   * db.table.where(
+   *   { id: 1 },
+   *   db.table.where({ name: 'John' }),
+   *   db.table.sql`a = b`,
+   * );
+   * ```
    *
-   * It will load all records from the joining table, both sides of the join may result in `null` values when there is no match.
+   * ## where sub query
    *
-   * All columns become nullable after using `fullJoin`.
+   * `where` handles a special callback where you can query a relation to get some value and filter by that value.
+   *
+   * It is useful for a faceted search. For instance, posts have tags, and we want to find all posts that have all the given tags.
    *
    * ```ts
-   * const result = await db.user
-   *   .rightJoin('messages')
-   *   .select('name', 'messages.text');
+   * const givenTags = ['typescript', 'node.js'];
    *
-   * // all columns can be null
-   * const ok: { name: string | null; text: string | null }[] = result;
+   * const posts = await db.post.where(
+   *   (post) =>
+   *     post.tags // query tags of the post
+   *       .whereIn('tagName', givenTags) // where name of the tag is inside array
+   *       .count() // count how many such tags were found
+   *       .equals(wantedTags.length), // the count must be exactly the length of array
+   *   // if the post has ony `typescript` tag but not the `node.js` it will be omitted
+   * );
    * ```
    *
-   * @param arg - {@link JoinFirstArg}
-   * @param args - {@link JoinArgs}
-   */
-  fullJoin(arg, ...args) {
-    return _join(this.clone(), false, "FULL JOIN", arg, args);
-  }
-  /**
-   * `joinLateral` allows joining a table with a sub-query that can reference the main table of current query and the other joined tables.
+   * This will produce an efficient SQL query:
+   *
+   * ```sql
+   * SELECT * FROM "post"
+   * WHERE (
+   *   SELECT count(*) = 3
+   *   FROM "tag" AS "tags"
+   *   WHERE "tag"."tagName" IN ('typescript', 'node.js')
+   *     -- join tags to the post via "postTag" table
+   *     AND EXISTS (
+   *       SELECT 1 FROM "postTag"
+   *       WHERE "postTag"."postId" = "post"."id"
+   *         AND "postTag"."tagId" = "tag"."id"
+   *     )
+   * )
+   * ```
    *
-   * Regular `JOIN` also can have a sub-query in its definition, but it cannot reference other tables of this query.
+   * In the example above we use `count()`, you can also use any other aggregate method instead, such as `min`, `max`, `avg`.
    *
-   * `JOIN LATERAL` of Postgres can have conditions in the `ON` statement, but `Orchid ORM` decided that there are no useful use-cases for such conditions, and it is only building a sub-query.
+   * The `count()` is chained with `equals` to check for a strict equality, any other operation is also allowed, such as `not`, `lt`, `gt`.
    *
-   * First argument is the other table you want to join, or a name of relation, or a name of `with` defined table.
+   * ## where special keys
    *
-   * Second argument is a callback where you can reference other tables using `on` and `orOn`, select columns, do `where` conditions, and use any other query methods to build a sub-query.
+   * The object passed to `where` can contain special keys, each of the keys corresponds to its own method and takes the same value as the type of argument of the method.
+   *
+   * For example:
    *
    * ```ts
-   * // joinLateral a Message table, alias it as `m`
-   * // without aliasing you can refer to the message by a table name
-   * User.joinLateral(Message.as('m'), (q) =>
-   *   q
-   *     // select message columns
-   *     .select('text')
-   *     // join the message to the user, column names can be prefixed with table names
-   *     .on('authorId', 'id')
-   *     // message columns are available without prefixing,
-   *     // outer table columns are available with a table name
-   *     .where({ text: 'some text', 'user.name': 'name' })
-   *     .order({ createdAt: 'DESC' }),
-   * )
-   *   // only selected message columns are available in select and where
-   *   .select('id', 'name', 'm.text')
-   *   .where({ 'm.text': messageData.text });
+   * db.table.where({
+   *   NOT: { key: 'value' },
+   *   OR: [{ name: 'a' }, { name: 'b' }],
+   *   IN: {
+   *     columns: ['id', 'name'],
+   *     values: [
+   *       [1, 'a'],
+   *       [2, 'b'],
+   *     ],
+   *   },
+   * });
    * ```
    *
-   * As well as simple `join`, `joinLateral` can select an object of full joined record:
+   * Using methods `whereNot`, `orWhere`, `whereIn` instead of this is a shorter and cleaner way, but in some cases, such object keys way may be more convenient.
    *
    * ```ts
-   * // join by relation name
-   * const result = await User.joinLateral(
-   *   'messages',
-   *   (q) => q.as('message'), // alias to 'message'
-   * ).select('name', { message: 'message.*' });
+   * db.table.where({
+   *   // see .whereNot
+   *   NOT: { id: 1 },
+   *   // can be an array:
+   *   NOT: [{ id: 1 }, { id: 2 }],
    *
-   * // result has the following type:
-   * const ok: {
-   *   name: string;
-   *   // full message is included:
-   *   message: { id: number; text: string; updatedAt: Date; createdAt: Date };
-   * }[] = result;
+   *   // see .orWhere
+   *   OR: [{ name: 'a' }, { name: 'b' }],
+   *   // can be an array:
+   *   // this will give id = 1 AND id = 2 OR id = 3 AND id = 4
+   *   OR: [
+   *     [{ id: 1 }, { id: 2 }],
+   *     [{ id: 3 }, { id: 4 }],
+   *   ],
+   *
+   *   // see .in, the key syntax requires an object with columns and values
+   *   IN: {
+   *     columns: ['id', 'name'],
+   *     values: [
+   *       [1, 'a'],
+   *       [2, 'b'],
+   *     ],
+   *   },
+   *   // can be an array:
+   *   IN: [
+   *     {
+   *       columns: ['id', 'name'],
+   *       values: [
+   *         [1, 'a'],
+   *         [2, 'b'],
+   *       ],
+   *     },
+   *     { columns: ['someColumn'], values: [['foo', 'bar']] },
+   *   ],
+   * });
    * ```
    *
-   * `message` can be aliased withing the `select` as well as in case of a simple `join`:
+   * ## column operators
+   *
+   * `where` argument can take an object where the key is the name of the operator and the value is its argument.
+   *
+   * Different types of columns support different sets of operators.
+   *
+   * All column operators can take a value of the same type as the column, a sub-query, or a raw SQL expression:
    *
    * ```ts
-   * // join by relation name
-   * const result = await User.joinLateral(
-   *   'messages',
-   *   (q) => q.as('message'), // alias to 'message'
-   * ).select('name', { msg: 'message.*' });
+   * import { sql } from 'orchid-orm';
    *
-   * // result has the following type:
-   * const ok: {
-   *   name: string;
-   *   // full message is included as msg:
-   *   msg: { id: number; text: string; updatedAt: Date; createdAt: Date };
-   * }[] = result;
+   * db.table.where({
+   *   numericColumn: {
+   *     // lower than 5
+   *     lt: 5,
+   *
+   *     // lower than the value returned by sub-query
+   *     lt: OtherTable.select('someNumber').take(),
+   *
+   *     // raw SQL expression produces WHERE "numericColumn" < "otherColumn" + 10
+   *     lt: sql`"otherColumn" + 10`,
+   *   },
+   * });
    * ```
    *
-   * @param arg - {@link JoinFirstArg}
-   * @param cb - {@link JoinLateralCallback}
-   */
-  joinLateral(arg, cb) {
-    return _joinLateral(this.clone(), "JOIN", arg, cb);
-  }
-  /**
-   * The same as {@link joinLateral}, but when no records found for the join it will result in `null`:
+   * ### Any type of column operators
+   *
+   * `equals` is a simple `=` operator, it may be useful for comparing column value with JSON object:
    *
    * ```ts
-   * const result = await db.user
-   *   .leftJoinLateral('messages', (q) => q.as('message'))
-   *   .select('name', 'message.text');
+   * db.table.where({
+   *  // when searching for an exact same JSON value, this won't work:
+   *   jsonColumn: someObject,
    *
-   * // result has the following type:
-   * const ok: { name: string; text: string | null }[] = result;
+   *   // use `{ equals: ... }` instead:
+   *   jsonColumn: { equals: someObject },
+   * });
    * ```
    *
-   * @param arg - {@link JoinFirstArg}
-   * @param cb - {@link JoinLateralCallback}
-   */
-  leftJoinLateral(arg, cb) {
-    return _joinLateral(this.clone(), "LEFT JOIN", arg, cb);
-  }
-}
-const makeOnItem = (joinTo, joinFrom, args) => {
-  return {
-    ON: {
-      joinTo,
-      joinFrom,
-      on: args
-    }
-  };
-};
-const pushQueryOn = (q, joinFrom, joinTo, ...on) => {
-  return pushQueryValue(q, "and", makeOnItem(joinFrom, joinTo, on));
-};
-const pushQueryOrOn = (q, joinFrom, joinTo, ...on) => {
-  return pushQueryValue(q, "or", [makeOnItem(joinFrom, joinTo, on)]);
-};
-const addQueryOn = (q, joinFrom, joinTo, ...args) => {
-  const cloned = q.clone();
-  setQueryObjectValue(
-    cloned,
-    "joinedShapes",
-    joinFrom.q.as || joinFrom.table,
-    joinFrom.q.shape
-  );
-  return pushQueryOn(cloned, joinFrom, joinTo, ...args);
-};
-const _queryJoinOn = (q, args) => {
-  return pushQueryOn(q, q.q.joinTo, q, ...args);
-};
-const _queryJoinOrOn = (q, args) => {
-  return pushQueryOrOn(q, q.q.joinTo, q, ...args);
-};
-const _queryJoinOnJsonPathEquals = (q, args) => {
-  return pushQueryValue(q, "and", { ON: args });
-};
-class OnQueryBuilder extends WhereQueryBase {
-  constructor(q, { shape, joinedShapes }, joinTo) {
-    super();
-    this.withData = orchidCore.emptyObject;
-    this.internal = q.internal;
-    this.table = typeof q === "object" ? q.table : q;
-    this.shape = shape;
-    this.q = {
-      shape,
-      joinedShapes
-    };
-    this.baseQuery = this;
-    if (typeof q === "object" && q.q.as) {
-      this.q.as = q.q.as;
-    }
-    this.q.joinTo = joinTo;
-  }
-  /**
-   * Use `on` to specify columns to join records.
+   * `not` is `!=` (aka `<>`) not equal operator:
    *
    * ```ts
-   * q
-   *   // left column is the db.message column, right column is the db.user column
-   *   .on('userId', 'id')
-   *   // table names can be provided:
-   *   .on('message.userId', 'user.id')
-   *   // operator can be specified:
-   *   .on('userId', '!=', 'id')
-   *   // operator can be specified with table names as well:
-   *   .on('message.userId', '!=', 'user.id')
-   *   // `.orOn` takes the same arguments as `.on` and acts like `.or`:
-   *   .on('userId', 'id') // where message.userId = user.id
+   * db.table.where({
+   *   anyColumn: { not: value },
+   * });
    * ```
    *
-   * @param args - columns to join with
-   */
-  on(...args) {
-    return _queryJoinOn(this.clone(), args);
-  }
-  /**
-   * Works as {@link on}, but the added conditions will be separated from previous with `OR`.
+   * `in` is for the `IN` operator to check if the column value is included in a list of values.
    *
-   * @param args - columns to join with
-   */
-  orOn(...args) {
-    return _queryJoinOrOn(this.clone(), args);
-  }
-  /**
-   * Use `onJsonPathEquals` to join record based on a field of their JSON column:
+   * Takes an array of the same type as a column, a sub-query that returns a list of values, or a raw SQL expression that returns a list.
    *
    * ```ts
-   * db.table.join(db.otherTable, (q) =>
-   *   // '$.key' is a JSON path
-   *   q.onJsonPathEquals('otherTable.data', '$.key', 'table.data', '$.key'),
-   * );
+   * db.table.where({
+   *   column: {
+   *     in: ['a', 'b', 'c'],
+   *
+   *     // WHERE "column" IN (SELECT "column" FROM "otherTable")
+   *     in: OtherTable.select('column'),
+   *
+   *     in: db.table.sql`('a', 'b')`,
+   *   },
+   * });
    * ```
    *
-   * @param args - columns and JSON paths to join with.
-   */
-  onJsonPathEquals(...args) {
-    return _queryJoinOnJsonPathEquals(this.clone(), args);
-  }
-}
-
-class JsonModifiers {
-  /**
-   * Return a JSON value/object/array where a given value is set at the given path.
-   * The path is an array of keys to access the value.
+   * `notIn` is for the `NOT IN` operator, and takes the same arguments as `in`
    *
-   * Can be used in `update` callback.
+   * ### Numeric, Date, and Time column operators
    *
-   * ```ts
-   * const result = await db.table.jsonSet('data', ['name'], 'new value').take();
+   * To compare numbers, dates, and times.
    *
-   * expect(result.data).toEqual({ name: 'new value' });
-   * ```
+   * `lt` is for `<` (lower than)
    *
-   * Optionally takes parameters of type `{ as?: string, createIfMissing?: boolean }`
+   * `lte` is for `<=` (lower than or equal)
+   *
+   * `gt` is for `>` (greater than)
+   *
+   * `gte` is for `>=` (greater than or equal)
    *
    * ```ts
-   * await db.table.jsonSet('data', ['name'], 'new value', {
-   *   as: 'alias', // select data as `alias`
-   *   createIfMissing: true, // ignored if missing by default
+   * db.table.where({
+   *   numericColumn: {
+   *     gt: 5,
+   *     lt: 10,
+   *   },
+   *
+   *   date: {
+   *     lte: new Date(),
+   *   },
+   *
+   *   time: {
+   *     gte: new Date(),
+   *   },
    * });
    * ```
    *
-   * @param column - name of JSON column, or a result of a nested json method
-   * @param path - path to value inside the json
-   * @param value - value to set into the json
-   * @param options - `as` to alias the json value when selecting, `createIfMissing: true` will create a new JSON property if it didn't exist before
-   */
-  jsonSet(column, path, value, options) {
-    var _a;
-    const q = this.clone();
-    const json = {
-      __json: [
-        "set",
-        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
-        typeof column === "string" ? q.q.shape[column] : column.__json[2],
-        column,
-        path,
-        value,
-        options
-      ]
-    };
-    return Object.assign(
-      pushQueryValue(q, "select", json),
-      json
-    );
-  }
-  /**
-   * Return a JSON value/object/array where a given value is inserted at the given JSON path. Value can be a single value or JSON object. If a value exists at the given path, the value is not replaced.
+   * `between` also works with numeric, dates, and time columns, it takes an array of two elements.
    *
-   * Can be used in `update` callback.
+   * Both elements can be of the same type as a column, a sub-query, or a raw SQL expression.
    *
    * ```ts
-   * // imagine user has data = { tags: ['two'] }
-   * const result = await db.table.jsonInsert('data', ['tags', 0], 'one').take();
+   * db.table.where({
+   *   column: {
+   *     // simple values
+   *     between: [1, 10],
    *
-   * // 'one' is inserted to 0 position
-   * expect(result.data).toEqual({ tags: ['one', 'two'] });
+   *     // sub-query and raw SQL expression
+   *     between: [OtherTable.select('column').take(), db.table.sql`2 + 2`],
+   *   },
+   * });
    * ```
    *
-   * Optionally takes parameters of type `{ as?: string, insertAfter?: boolean }`
+   * ### Text column operators
    *
-   * ```ts
-   * // imagine user has data = { tags: ['one'] }
-   * const result = await db.table
-   *   .jsonInsert('data', ['tags', 0], 'two', {
-   *     as: 'alias', // select as an alias
-   *     insertAfter: true, // insert after the specified position
-   *   })
-   *   .take();
+   * For `text`, `char`, `varchar`, and `json` columns.
    *
-   * // 'one' is inserted to 0 position
-   * expect(result.alias).toEqual({ tags: ['one', 'two'] });
-   * ```
-   * @param column - name of JSON column, or a result of a nested json method
-   * @param path - path to the array inside the json, last path element is index to insert into
-   * @param value - value to insert into the json array
-   * @param options - `as` to alias the json value when selecting, `insertAfter: true` to insert after the specified position
-   */
-  jsonInsert(column, path, value, options) {
-    var _a;
-    const q = this.clone();
-    const json = {
-      __json: [
-        "insert",
-        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
-        typeof column === "string" ? q.q.shape[column] : column.__json[2],
-        column,
-        path,
-        value,
-        options
-      ]
-    };
-    return Object.assign(
-      pushQueryValue(q, "select", json),
-      json
-    );
-  }
-  /**
-   * Return a JSON value/object/array where a given value is removed at the given JSON path.
+   * `json` is stored as text, so it has text operators. Use the `jsonb` type for JSON operators.
    *
-   * Can be used in `update` callback.
+   * Takes a string, or sub-query returning string, or raw SQL expression as well as other operators.
    *
    * ```ts
-   * // imagine a user has data = { tags: ['one', 'two'] }
-   * const result = await db.table
-   *   .jsonRemove(
-   *     'data',
-   *     ['tags', 0],
-   *     // optional parameters:
-   *     {
-   *       as: 'alias', // select as an alias
-   *     },
-   *   )
-   *   .take();
-   *
-   * expect(result.alias).toEqual({ tags: ['two'] });
+   * db.table.where({
+   *   textColumn: {
+   *     // WHERE "textColumn" LIKE '%string%'
+   *     contains: 'string',
+   *     // WHERE "textColumn" ILIKE '%string%'
+   *     containsInsensitive: 'string',
+   *     // WHERE "textColumn" LIKE 'string%'
+   *     startsWith: 'string',
+   *     // WHERE "textColumn" ILIKE 'string%'
+   *     startsWithInsensitive: 'string',
+   *     // WHERE "textColumn" LIKE '%string'
+   *     endsWith: 'string',
+   *     // WHERE "textColumn" ILIKE '%string'
+   *     endsWithInsensitive: 'string',
+   *   },
+   * });
    * ```
    *
-   * @param column - name of JSON column, or a result of a nested json method
-   * @param path - path to the array inside the json, last path element is index to remove this element
-   * @param options - `as` to alias the json value when selecting
-   */
-  jsonRemove(column, path, options) {
-    var _a;
-    const q = this.clone();
-    const json = {
-      __json: [
-        "remove",
-        (_a = options == null ? void 0 : options.as) != null ? _a : typeof column === "string" ? column : column.__json[1],
-        typeof column === "string" ? q.q.shape[column] : column.__json[2],
-        column,
-        path
-      ]
-    };
-    return Object.assign(
-      pushQueryValue(q, "select", json),
-      json
-    );
-  }
-  /**
-   * Selects a value from JSON data using a JSON path.
+   * ### JSONB column operators
+   *
+   * For the `jsonb` column, note that the `json` type has text operators instead.
+   *
+   * `jsonPath` operator: compare a column value under a given JSON path with the provided value.
+   *
+   * Value can be of any type to compare with JSON value, or it can be a sub-query or a raw SQL expression.
    *
    * ```ts
-   * import { columnTypes } from 'orchid-orm';
+   * db.table.where({
+   *   jsonbColumn: {
+   *     jsonPath: [
+   *       '$.name', // first element is JSON path
+   *       '=', // second argument is comparison operator
+   *       'value', // third argument is a value to compare with
+   *     ],
+   *   },
+   * });
+   * ```
    *
-   * db.table.jsonPathQuery(
-   *   columnTypes.text(3, 100), // type of the value
-   *   'data', // name of the JSON column
-   *   '$.name', // JSON path
-   *   'name', // select value as name
+   * `jsonSupersetOf`: check if the column value is a superset of provided value.
    *
-   *   // Optionally supports `vars` and `silent` options
-   *   // check Postgres docs for jsonb_path_query for details
-   *   {
-   *     vars: 'vars',
-   *     silent: true,
+   * For instance, it is true if the column has JSON `{ "a": 1, "b": 2 }` and provided value is `{ "a": 1 }`.
+   *
+   * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
+   *
+   * ```ts
+   * db.table.where({
+   *   jsonbColumn: {
+   *     jsonSupersetOf: { a: 1 },
    *   },
-   * );
+   * });
    * ```
    *
-   * Nested JSON operations can be used in place of JSON column name:
+   * `jsonSubsetOf`: check if the column value is a subset of provided value.
+   *
+   * For instance, it is true if the column has JSON `{ "a": 1 }` and provided value is `{ "a": 1, "b": 2 }`.
+   *
+   * Takes the value of any type, or sub query which returns a single value, or a raw SQL expression.
    *
    * ```ts
-   * db.table.jsonPathQuery(
-   *   columnTypes.text(3, 100),
-   *   // Available: .jsonSet, .jsonInsert, .jsonRemove
-   *   db.table.jsonSet('data', ['key'], 'value'),
-   *   '$.name',
-   *   'name',
-   * );
+   * db.table.where({
+   *   jsonbColumn: {
+   *     jsonSupersetOf: { a: 1 },
+   *   },
+   * });
    * ```
    *
-   * @param type - provide a column type to have a correct result type
-   * @param column - name of JSON column, or a result of a nested json method
-   * @param path - special JSON path string to reference a JSON value
-   * @param as - optional alias for the selected value
-   * @param options - supports `vars` and `silent`, check Postgres docs of `json_path_query` for these
+   * @param args - {@link WhereArgs}
    */
-  jsonPathQuery(type, column, path, as, options) {
-    const q = this.clone();
-    const json = {
-      __json: ["pathQuery", as, type, column, path, options]
-    };
-    return Object.assign(
-      pushQueryValue(q, "select", json),
-      json
+  where(...args) {
+    return _queryWhere(
+      this.clone(),
+      args
     );
   }
-}
-class JsonMethods {
   /**
-   * Wraps the query in a way to select a single JSON string.
-   * So that JSON encoding is done on a database side, and the application doesn't have to turn a response to a JSON.
-   * It may be better for performance in some cases.
+   * Use a custom SQL expression in `WHERE` statement:
    *
    * ```ts
-   * // json is a JSON string that you can directly send as a response.
-   * const json = await db.table.select('id', 'name').json();
+   * db.table.where`a = b`;
+   *
+   * // or
+   * db.table.where(db.table.sql`a = b`);
+   *
+   * // or
+   * import { raw } from 'orchid-orm';
+   *
+   * db.table.where(raw`a = b`);
    * ```
    *
-   * @param coalesce
+   * @param args - SQL expression
    */
-  json(coalesce) {
-    return queryJson(
+  whereSql(...args) {
+    return _queryWhereSql(
       this.clone(),
-      coalesce
+      args
     );
   }
-}
-
-const logColors = {
-  boldCyanBright: (message) => `\x1B[1m\x1B[96m${message}\x1B[39m\x1B[22m`,
-  boldBlue: (message) => `\x1B[1m\x1B[34m${message}\x1B[39m\x1B[22m`,
-  boldYellow: (message) => `\x1B[1m\x1B[33m${message}\x1B[39m\x1B[22m`,
-  boldMagenta: (message) => `\x1B[1m\x1B[33m${message}\x1B[39m\x1B[22m`,
-  boldRed: (message) => `\x1B[1m\x1B[31m${message}\x1B[39m\x1B[22m`
-};
-const makeMessage = (colors, timeColor, time, sqlColor, sql, valuesColor, values) => {
-  const elapsed = process.hrtime(time);
-  const formattedTime = `(${elapsed[0] ? `${elapsed[0]}s ` : ""}${(elapsed[1] / 1e6).toFixed(1)}ms)`;
-  const result = `${colors ? timeColor(formattedTime) : formattedTime} ${colors ? sqlColor(sql) : sql}`;
-  if (!values.length) {
-    return result;
-  }
-  const formattedValues = `[${values.map(quote).join(", ")}]`;
-  return `${result} ${colors ? valuesColor(formattedValues) : formattedValues}`;
-};
-const logParamToLogObject = (logger, log) => {
-  if (!log)
-    return;
-  const logObject = Object.assign(
-    {
-      colors: true,
-      beforeQuery() {
-        return process.hrtime();
-      },
-      afterQuery(sql, time) {
-        logger.log(
-          makeMessage(
-            colors,
-            logColors.boldCyanBright,
-            time,
-            logColors.boldBlue,
-            sql.text,
-            logColors.boldYellow,
-            sql.values
-          )
-        );
-      },
-      onError(error, sql, time) {
-        const message = `Error: ${error.message}`;
-        logger.error(
-          `${makeMessage(
-            colors,
-            logColors.boldMagenta,
-            time,
-            logColors.boldRed,
-            sql.text,
-            logColors.boldYellow,
-            sql.values
-          )} ${colors ? logColors.boldRed(message) : message}`
-        );
-      }
-    },
-    log === true ? {} : log
-  );
-  const colors = logObject.colors;
-  return logObject;
-};
-class QueryLog {
-  log(log = true) {
-    const q = this.clone();
-    q.q.log = logParamToLogObject(q.q.logger, log);
-    return q;
-  }
-}
-
-var __defProp$5 = Object.defineProperty;
-var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
-var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
-var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$5 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$5.call(b, prop))
-      __defNormalProp$5(a, prop, b[prop]);
-  if (__getOwnPropSymbols$5)
-    for (var prop of __getOwnPropSymbols$5(b)) {
-      if (__propIsEnum$5.call(b, prop))
-        __defNormalProp$5(a, prop, b[prop]);
-    }
-  return a;
-};
-const mergableObjects = {
-  shape: true,
-  withShapes: true,
-  parsers: true,
-  defaults: true,
-  joinedShapes: true,
-  joinedParsers: true
-};
-class MergeQueryMethods {
-  merge(q) {
-    const query = this.clone();
-    const a = query.q;
-    const b = q.q;
-    for (const key in b) {
-      const value = b[key];
-      switch (typeof value) {
-        case "boolean":
-        case "string":
-        case "number":
-          a[key] = value;
-          break;
-        case "object":
-          if (Array.isArray(value)) {
-            a[key] = a[key] ? [...a[key], ...value] : value;
-          } else if (mergableObjects[key]) {
-            a[key] = a[key] ? __spreadValues$5(__spreadValues$5({}, a[key]), value) : value;
-          } else {
-            a[key] = value;
-          }
-          break;
-      }
-    }
-    a[orchidCore.getValueKey] = b[orchidCore.getValueKey];
-    if (b.returnType)
-      a.returnType = b.returnType;
-    return query;
-  }
-}
-
-var __defProp$4 = Object.defineProperty;
-var __defProps$2 = Object.defineProperties;
-var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
-var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
-var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues$4 = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp$4.call(b, prop))
-      __defNormalProp$4(a, prop, b[prop]);
-  if (__getOwnPropSymbols$4)
-    for (var prop of __getOwnPropSymbols$4(b)) {
-      if (__propIsEnum$4.call(b, prop))
-        __defNormalProp$4(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
-class With {
   /**
-   * Add Common Table Expression (CTE) to the query.
+   * `whereNot` takes the same argument as `where`,
+   * multiple conditions are combined with `AND`,
+   * the whole group of conditions is negated with `NOT`.
    *
    * ```ts
-   * import { columnTypes } from 'orchid-orm';
-   * import { NumberColumn } from './number';
-   *
-   * // .with optionally accepts such options:
-   * type WithOptions = {
-   *   // list of columns returned by this WITH statement
-   *   // by default all columns from provided column shape will be included
-   *   // true is for default behavior
-   *   columns?: string[] | boolean;
-   *
-   *   // Adds RECURSIVE keyword:
-   *   recursive?: true;
-   *
-   *   // Adds MATERIALIZED keyword:
-   *   materialized?: true;
-   *
-   *   // Adds NOT MATERIALIZED keyword:
-   *   notMaterialized?: true;
-   * };
+   * // find records of different colors than red
+   * db.table.whereNot({ color: 'red' });
+   * // WHERE NOT color = 'red'
+   * db.table.whereNot({ one: 1, two: 2 });
+   * // WHERE NOT (one = 1 AND two = 2)
+   * ```
    *
-   * // accepts columns shape and a raw expression:
-   * db.table.with(
-   *   'alias',
-   *   {
-   *     id: columnTypes.integer(),
-   *     name: columnTypes.text(3, 100),
-   *   },
-   *   db.table.sql`SELECT id, name FROM "someTable"`,
-   * );
+   * @param args - {@link WhereArgs}
+   */
+  whereNot(...args) {
+    return _queryWhereNot(
+      this.clone(),
+      args
+    );
+  }
+  /**
+   * `whereNot` version accepting SQL expression:
    *
-   * // accepts query:
-   * db.table.with('alias', db.table.all());
+   * ```ts
+   * db.table.whereNot`sql expression`
+   * ```
    *
-   * // accepts a callback for a query builder:
-   * db.table.with('alias', (qb) =>
-   *   qb.select({ one: db.table.sql((t) => t.integer())`1` }),
-   * );
+   * @param args - SQL expression
+   */
+  whereNotSql(...args) {
+    return _queryWhereNotSql(this.clone(), args);
+  }
+  /**
+   * `orWhere` is accepting the same arguments as {@link where}, joining arguments with `OR`.
    *
-   * // All mentioned forms can accept options as a second argument:
-   * db.table.with(
-   *   'alias',
-   *   {
-   *     recursive: true,
-   *     materialized: true,
-   *   },
-   *   rawOrQueryOrCallback,
-   * );
-   * ```
+   * Columns in single arguments are still joined with `AND`.
    *
-   * Defined `WITH` table can be used in `.from` or `.join` with all the type safeness:
+   * The database is processing `AND` before `OR`, so this should be intuitively clear.
    *
    * ```ts
-   * db.table.with('alias', db.table.all()).from('alias').select('alias.id');
+   * db.table.where({ id: 1, color: 'red' }).orWhere({ id: 2, color: 'blue' });
+   * // equivalent:
+   * db.table.orWhere({ id: 1, color: 'red' }, { id: 2, color: 'blue' });
+   * ```
    *
-   * db.table
-   *   .with('alias', db.table.all())
-   *   .join('alias', 'alias.id', 'user.id')
-   *   .select('alias.id');
+   * This query will produce such SQL (simplified):
+   *
+   * ```sql
+   * SELECT * FROM "table"
+   * WHERE id = 1 AND color = 'red'
+   *    OR id = 2 AND color = 'blue'
    * ```
    *
-   * @param args - first argument is an alias for this CTE, other arguments can be column shape, query object, or raw SQL.
+   * @param args - {@link WhereArgs} will be joined with `OR`
    */
-  with(...args) {
-    const q = this.clone();
-    let options = args.length === 3 && !orchidCore.isExpression(args[2]) || args.length === 4 ? args[1] : void 0;
-    const last = args[args.length - 1];
-    const query = typeof last === "function" ? last(q.queryBuilder) : last;
-    const shape = args.length === 4 ? args[2] : orchidCore.isExpression(query) ? args[1] : query.q.shape;
-    if ((options == null ? void 0 : options.columns) === true) {
-      options = __spreadProps$2(__spreadValues$4({}, options), {
-        columns: Object.keys(shape)
-      });
-    }
-    pushQueryValue(q, "with", [args[0], options || orchidCore.emptyObject, query]);
-    return setQueryObjectValue(q, "withShapes", args[0], shape);
+  orWhere(...args) {
+    return _queryOr(this.clone(), args);
   }
-}
-
-class Union {
   /**
-   * Creates a union query, taking an array or a list of callbacks, builders, or raw statements to build the union statement, with optional boolean `wrap`.
-   * If the `wrap` parameter is true, the queries will be individually wrapped in parentheses.
+   * `orWhereNot` takes the same arguments as {@link orWhere}, and prepends each condition with `NOT` just as {@link whereNot} does.
+   *
+   * @param args - {@link WhereArgs} will be prefixed with `NOT` and joined with `OR`
+   */
+  orWhereNot(...args) {
+    return _queryOrNot(
+      this.clone(),
+      args
+    );
+  }
+  /**
+   * `whereIn` and related methods are for the `IN` operator to check for inclusion in a list of values.
+   *
+   * When used with a single column it works equivalent to the `in` column operator:
    *
    * ```ts
-   * SomeTable.select('id', 'name').union(
+   * db.table.whereIn('column', [1, 2, 3]);
+   * // the same as:
+   * db.table.where({ column: [1, 2, 3] });
+   * ```
+   *
+   * `whereIn` can support a tuple of columns, that's what the `in` operator cannot support:
+   *
+   * ```ts
+   * db.table.whereIn(
+   *   ['id', 'name'],
    *   [
-   *     OtherTable.select('id', 'name'),
-   *     SomeTable.sql`SELECT id, name FROM "thirdTable"`,
+   *     [1, 'Alice'],
+   *     [2, 'Bob'],
    *   ],
-   *   true, // optional wrap parameter
    * );
    * ```
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * It supports sub query which should return records with columns of the same type:
+   *
+   * ```ts
+   * db.table.whereIn(['id', 'name'], OtherTable.select('id', 'name'));
+   * ```
+   *
+   * It supports raw SQL expression:
+   *
+   * ```ts
+   * db.table.whereIn(['id', 'name'], db.table.sql`((1, 'one'), (2, 'two'))`);
+   * ```
    */
-  union(args, wrap) {
-    return pushQueryArray(
+  whereIn(...args) {
+    return _queryWhereIn(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "UNION", wrap }))
+      true,
+      args[0],
+      args[1]
     );
   }
   /**
-   * Same as `union`, but allows duplicated rows.
+   * Takes the same arguments as {@link whereIn}.
+   * Add a `WHERE IN` condition prefixed with `OR` to the query:
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * ```ts
+   * db.table.whereIn('a', [1, 2, 3]).orWhereIn('b', ['one', 'two']);
+   * ```
    */
-  unionAll(args, wrap) {
-    return pushQueryArray(
+  orWhereIn(...args) {
+    return _queryWhereIn(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "UNION ALL", wrap }))
+      false,
+      args[0],
+      args[1]
     );
   }
   /**
-   * Same as `union`, but uses a `INTERSECT` SQL keyword instead
+   * Acts as `whereIn`, but negates the condition with `NOT`:
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * ```ts
+   * db.table.whereNotIn('color', ['red', 'green', 'blue']);
+   * ```
    */
-  intersect(args, wrap) {
-    return pushQueryArray(
+  whereNotIn(...args) {
+    return _queryWhereIn(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "INTERSECT", wrap }))
+      true,
+      args[0],
+      args[1],
+      true
     );
   }
   /**
-   * Same as `intersect`, but allows duplicated rows.
+   * Acts as `whereIn`, but prepends `OR` to the condition and negates it with `NOT`:
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * ```ts
+   * db.table.whereNotIn('a', [1, 2, 3]).orWhereNoIn('b', ['one', 'two']);
+   * ```
    */
-  intersectAll(args, wrap) {
-    return pushQueryArray(
+  orWhereNotIn(...args) {
+    return _queryWhereIn(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "INTERSECT ALL", wrap }))
+      false,
+      args[0],
+      args[1],
+      true
     );
   }
   /**
-   * Same as `union`, but uses an `EXCEPT` SQL keyword instead
+   * `whereExists` is for support of the `WHERE EXISTS (query)` clause.
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * This method is accepting the same arguments as `join`, see the {@link Join.join} section for more details.
+   *
+   * ```ts
+   * // find users who have accounts
+   * // find by a relation name if it's defined
+   * db.user.whereExists('account');
+   *
+   * // find using a table and a join conditions
+   * db.user.whereExists(db.account, 'account.id', 'user.id');
+   *
+   * // find using a query builder in a callback:
+   * db.user.whereExists(db.account, (q) => q.on('account.id', '=', 'user.id'));
+   * ```
    */
-  except(args, wrap) {
-    return pushQueryArray(
+  whereExists(arg, ...args) {
+    return _queryWhereExists(
       this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "EXCEPT", wrap }))
+      arg,
+      args
     );
   }
   /**
-   * Same as `except`, but allows duplicated rows.
+   * Acts as `whereExists`, but prepends the condition with `OR`:
    *
-   * @param args - array of queries or raw SQLs
-   * @param wrap - provide `true` if you want the queries to be wrapped into parentheses
+   * ```ts
+   * // find users who have an account or a profile,
+   * // imagine that the user has both `account` and `profile` relations defined.
+   * db.user.whereExist('account').orWhereExists('profile');
+   * ```
    */
-  exceptAll(args, wrap) {
-    return pushQueryArray(
-      this.clone(),
-      "union",
-      args.map((arg) => ({ arg, kind: "EXCEPT ALL", wrap }))
+  orWhereExists(arg, ...args) {
+    const q = this.clone();
+    return _queryOr(q, existsArgs(q, arg, args));
+  }
+  /**
+   * Acts as `whereExists`, but negates the condition with `NOT`:
+   *
+   * ```ts
+   * // find users who don't have an account,
+   * // image that the user `belongsTo` or `hasOne` account.
+   * db.user.whereNotExist('account');
+   * ```
+   *
+   * @param arg - relation name, or a query object, or a `with` table alias, or a callback returning a query object.
+   * @param args - no arguments needed when the first argument is a relation name, or conditions to join the table with.
+   */
+  whereNotExists(arg, ...args) {
+    const q = this.clone();
+    return _queryWhereNot(
+      q,
+      existsArgs(q, arg, args)
     );
   }
+  /**
+   * Acts as `whereExists`, but prepends the condition with `OR` and negates it with `NOT`:
+   *
+   * ```ts
+   * // find users who don't have an account OR who don't have a profile
+   * // imagine that the user has both `account` and `profile` relations defined.
+   * db.user.whereNotExists('account').orWhereNotExists('profile');
+   * ```
+   */
+  orWhereNotExists(arg, ...args) {
+    const q = this.clone();
+    return _queryOrNot(q, existsArgs(q, arg, args));
+  }
 }
 
 var __defProp$3 = Object.defineProperty;
@@ -9822,6 +9980,22 @@ class RawSqlMethods {
   }
 }
 
+class QueryBase {
+  constructor() {
+    this.q = {};
+  }
+  /**
+   * Clones the current query chain, useful for re-using partial query snippets in other queries without mutating the original.
+   *
+   * Used under the hood, and not really needed on the app side.
+   */
+  clone() {
+    const cloned = Object.create(this.baseQuery);
+    cloned.q = getClonedQueryData(this.q);
+    return cloned;
+  }
+}
+
 class TransformMethods {
   /**
    * Transform the result of the query right after loading it.
@@ -10659,7 +10833,7 @@ orchidCore.applyMixins(QueryMethods, [
   Select,
   From,
   Join,
-  OnQueryBuilder,
+  OnMethods,
   With,
   Union,
   JsonModifiers,
@@ -10960,7 +11134,6 @@ const performQuery = async (q, args, method) => {
 };
 orchidCore.applyMixins(Db, [QueryMethods]);
 Db.prototype.constructor = Db;
-Db.prototype.onQueryBuilder = OnQueryBuilder;
 const createDb = (_a) => {
   var _b = _a, {
     log,
@@ -11207,7 +11380,7 @@ exports.NotFoundError = NotFoundError;
 exports.NumberAsStringBaseColumn = NumberAsStringBaseColumn;
 exports.NumberBaseColumn = NumberBaseColumn;
 exports.OnConflictQueryBuilder = OnConflictQueryBuilder;
-exports.OnQueryBuilder = OnQueryBuilder;
+exports.OnMethods = OnMethods;
 exports.Operators = Operators;
 exports.OrchidOrmError = OrchidOrmError;
 exports.OrchidOrmInternalError = OrchidOrmInternalError;
@@ -11249,7 +11422,6 @@ exports.Update = Update;
 exports.VarCharColumn = VarCharColumn;
 exports.VirtualColumn = VirtualColumn;
 exports.Where = Where;
-exports.WhereQueryBase = WhereQueryBase;
 exports.With = With;
 exports.XMLColumn = XMLColumn;
 exports._queryAfterSaveCommit = _queryAfterSaveCommit;
@@ -11301,6 +11473,7 @@ exports._queryUpdate = _queryUpdate;
 exports._queryUpdateOrThrow = _queryUpdateOrThrow;
 exports._queryUpdateRaw = _queryUpdateRaw;
 exports._queryWhere = _queryWhere;
+exports._queryWhereExists = _queryWhereExists;
 exports._queryWhereIn = _queryWhereIn;
 exports._queryWhereNot = _queryWhereNot;
 exports._queryWhereNotSql = _queryWhereNotSql;