pqb 0.43.0 → 0.43.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { ExpressionTypeMethod, Expression, RawSQLBase, emptyObject, isTemplateLiteralArgs, ColumnTypeBase, setColumnData, pushColumnData, templateLiteralSQLToCode, quoteObjectKey, toArray, emptyArray, singleQuote, addCode, singleQuoteArray, objectHasValues, toSnakeCase, columnDefaultArgumentToCode, columnErrorMessagesToCode, getValueKey, addValue, isExpression, joinTruthy, stringDataToCode, getDefaultLanguage, dateDataToCode, returnArg as returnArg$1, noop, pushOrNewArrayToObject, arrayDataToCode, numberDataToCode, logColors, applyTransforms, callWithThis, setParserToQuery, isRawSQL, pushOrNewArray, setDefaultNowFn, setDefaultLanguage, setCurrentColumnName, makeTimestampsHelpers, setAdapterConnectRetry, isObjectEmpty, ValExpression, applyMixins, snakeCaseKey } from 'orchid-core';
+import { ExpressionTypeMethod, Expression, RawSQLBase, emptyObject, isTemplateLiteralArgs, ColumnTypeBase, setColumnData, pushColumnData, templateLiteralSQLToCode, quoteObjectKey, toArray, emptyArray, singleQuote, addCode, singleQuoteArray, objectHasValues, toSnakeCase, columnDefaultArgumentToCode, columnErrorMessagesToCode, getValueKey, addValue, isExpression, joinTruthy, stringDataToCode, getDefaultLanguage, dateDataToCode, returnArg as returnArg$1, noop, pushOrNewArrayToObject, arrayDataToCode, numberDataToCode, logColors, applyTransforms, callWithThis, setParserToQuery, pushOrNewArray, isRawSQL, setDefaultNowFn, setDefaultLanguage, setCurrentColumnName, makeTimestampsHelpers, setAdapterConnectRetry, isObjectEmpty, ValExpression, applyMixins, snakeCaseKey } from 'orchid-core';
 import pg from 'pg';
 import { inspect } from 'node:util';
 import { AsyncLocalStorage } from 'node:async_hooks';
@@ -810,8 +810,10 @@ const columnExcludesToCode = (items) => {
   }
   return code;
 };
-const columnCheckToCode = (ctx, { sql, name }, columnName) => {
-  return `.check(${sql.toCode(ctx.t)}${name && name !== `${ctx.table}_${columnName}_check` ? `, { name: '${name}' }` : ""})`;
+const columnCheckToCode = (ctx, checks) => {
+  return checks.map(
+    ({ sql, name }) => `.check(${sql.toCode(ctx.t)}${name ? `, '${name}'` : ""})`
+  ).join("");
 };
 const identityToCode = (identity, dataType) => {
   const code = [];
@@ -895,8 +897,8 @@ const columnCode = (type, ctx, key, code) => {
     }
   }
   if (data.comment) addCode(code, `.comment(${singleQuote(data.comment)})`);
-  if (data.check) {
-    addCode(code, columnCheckToCode(ctx, data.check, name));
+  if (data.checks) {
+    addCode(code, columnCheckToCode(ctx, data.checks));
   }
   if (data.errors) {
     for (const part of columnErrorMessagesToCode(data.errors)) {
@@ -1243,11 +1245,13 @@ class TextColumn extends TextBaseColumn {
     return textColumnToCode(this, ctx, key);
   }
 }
+const byteaParse = (val) => typeof val === "string" ? Buffer.from(val.slice(2), "hex") : val;
 class ByteaColumn extends ColumnType {
   constructor(schema) {
     super(schema, schema.buffer());
     this.dataType = "bytea";
     this.operators = Operators.text;
+    setColumnDefaultParse(this, byteaParse);
   }
   toCode(ctx, key) {
     return columnCode(this, ctx, key, `bytea()`);
@@ -4464,7 +4468,7 @@ function maybeWrappedThen(resolve, reject) {
   let afterHooks;
   let afterCommitHooks;
   if (q.type) {
-    if (q.type === "insert") {
+    if (q.type === "insert" || q.type === "upsert") {
       beforeHooks = q.beforeCreate;
       afterHooks = q.afterCreate;
       afterCommitHooks = q.afterCreateCommit;
@@ -4542,14 +4546,18 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
       if (log) {
         logData = log.beforeQuery(sql);
       }
-      queryResult = await adapter[queryMethodByReturnType[tempReturnType]](sql);
-      if (query.patchResult) {
-        await query.patchResult(q, queryResult);
-      }
+      queryResult = await execQuery(
+        adapter,
+        queryMethodByReturnType[tempReturnType],
+        sql
+      );
       if (log) {
         log.afterQuery(sql, logData);
         sql = void 0;
       }
+      if (query.patchResult) {
+        await query.patchResult(q, hookSelect, queryResult);
+      }
       result = query.handleResult(q, tempReturnType, queryResult);
     } else {
       const queryMethod = queryMethodByReturnType[tempReturnType];
@@ -4563,7 +4571,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
         if (log) {
           logData = log.beforeQuery(sql);
         }
-        const result2 = await adapter[queryMethod](sql);
+        const result2 = await execQuery(adapter, queryMethod, sql);
         if (queryResult) {
           queryResult.rowCount += result2.rowCount;
           queryResult.rows.push(...result2.rows);
@@ -4581,7 +4589,7 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
         if (log) log.afterQuery(commitSql$1, logData);
       }
       if (query.patchResult) {
-        await query.patchResult(q, queryResult);
+        await query.patchResult(q, hookSelect, queryResult);
       }
       result = query.handleResult(q, tempReturnType, queryResult);
     }
@@ -4709,6 +4717,17 @@ const then = async (q, adapter, trx, beforeHooks, afterHooks, afterCommitHooks,
     return reject?.(error);
   }
 };
+const execQuery = (adapter, method, sql) => {
+  return adapter[method](sql).then(
+    (result) => {
+      if (result.rowCount && !result.rows.length) {
+        result.rows.length = result.rowCount;
+        result.rows.fill({});
+      }
+      return result;
+    }
+  );
+};
 const assignError = (to, from) => {
   to.message = from.message;
   to.length = from.length;
@@ -5648,6 +5667,306 @@ function queryJson(self, coalesce) {
   return q;
 }
 
+const MAX_BINDING_PARAMS = 65536;
+
+const quotedColumns = [];
+const makeInsertSql = (ctx, q, query, quotedAs) => {
+  const { columns, shape, inCTE } = query;
+  quotedColumns.length = columns.length;
+  for (let i = 0, len = columns.length; i < len; i++) {
+    quotedColumns[i] = `"${shape[columns[i]]?.data.name || columns[i]}"`;
+  }
+  let runtimeDefaults;
+  if (q.internal.runtimeDefaultColumns) {
+    runtimeDefaults = [];
+    for (const key of q.internal.runtimeDefaultColumns) {
+      if (!columns.includes(key)) {
+        const column = shape[key];
+        quotedColumns.push(`"${column.data.name || key}"`);
+        runtimeDefaults.push(column.data.runtimeDefault);
+      }
+    }
+  }
+  let values = query.values;
+  if (quotedColumns.length === 0) {
+    const key = Object.keys(q.shape)[0];
+    const column = q.shape[key];
+    quotedColumns[0] = `"${column?.data.name || key}"`;
+    if (Array.isArray(values) && Array.isArray(values[0])) {
+      values = values.map(() => [void 0]);
+    }
+  }
+  ctx.sql.push(
+    `INSERT INTO ${quotedAs}(${quotedColumns.join(", ")})`,
+    null
+  );
+  const QueryClass = ctx.queryBuilder.constructor;
+  if (query.onConflict) {
+    ctx.sql.push("ON CONFLICT");
+    const { target } = query.onConflict;
+    if (target) {
+      if (typeof target === "string") {
+        ctx.sql.push(`("${shape[target]?.data.name || target}")`);
+      } else if (Array.isArray(target)) {
+        ctx.sql.push(
+          `(${target.reduce(
+            (sql, item, i) => sql + (i ? ", " : "") + `"${shape[item]?.data.name || item}"`,
+            ""
+          )})`
+        );
+      } else if ("toSQL" in target) {
+        ctx.sql.push(target.toSQL(ctx, quotedAs));
+      } else {
+        ctx.sql.push(`ON CONSTRAINT "${target.constraint}"`);
+      }
+    }
+    if ("merge" in query.onConflict) {
+      let sql;
+      const { merge } = query.onConflict;
+      if (merge) {
+        if (typeof merge === "string") {
+          const name = shape[merge]?.data.name || merge;
+          sql = `DO UPDATE SET "${name}" = excluded."${name}"`;
+        } else if ("except" in merge) {
+          sql = mergeColumnsSql(columns, quotedColumns, target, merge.except);
+        } else {
+          sql = `DO UPDATE SET ${merge.reduce((sql2, item, i) => {
+            const name = shape[item]?.data.name || item;
+            return sql2 + (i ? ", " : "") + `"${name}" = excluded."${name}"`;
+          }, "")}`;
+        }
+      } else {
+        sql = mergeColumnsSql(columns, quotedColumns, target);
+      }
+      ctx.sql.push(sql);
+    } else if (query.onConflict.set) {
+      let sql;
+      const { set } = query.onConflict;
+      if (isExpression(set)) {
+        sql = set.toSQL(ctx, quotedAs);
+      } else {
+        const arr = [];
+        for (const key in set) {
+          arr.push(
+            `"${shape[key]?.data.name || key}" = ${addValue(
+              ctx.values,
+              set[key]
+            )}`
+          );
+        }
+        sql = arr.join(", ");
+      }
+      ctx.sql.push("DO UPDATE SET", sql);
+    } else {
+      ctx.sql.push("DO NOTHING");
+    }
+  }
+  pushWhereStatementSql(ctx, q, query, quotedAs);
+  let returning;
+  if (inCTE?.selectNum) {
+    returning = {
+      select: inCTE.returning?.select ? "1, " + inCTE.returning.select : "1",
+      hookSelect: inCTE.returning?.hookSelect
+    };
+  } else {
+    returning = makeReturningSql(ctx, q, query, quotedAs, 2);
+  }
+  if (returning.select) ctx.sql.push("RETURNING", returning.select);
+  if (query.kind === "object") {
+    const valuesSql = [];
+    let ctxValues = ctx.values;
+    const restValuesLen = ctxValues.length;
+    let currentValuesLen = restValuesLen;
+    let batch;
+    for (let i = 0; i < values.length; i++) {
+      let encodedRow = encodeRow(
+        ctx,
+        ctxValues,
+        q,
+        QueryClass,
+        values[i],
+        runtimeDefaults,
+        quotedAs
+      );
+      if (!inCTE) encodedRow = "(" + encodedRow + ")";
+      if (ctxValues.length > MAX_BINDING_PARAMS) {
+        if (ctxValues.length - currentValuesLen > MAX_BINDING_PARAMS) {
+          throw new Error(
+            `Too many parameters for a single insert row, max is ${MAX_BINDING_PARAMS}`
+          );
+        }
+        ctx.sql[1] = (inCTE ? "SELECT " : "VALUES ") + valuesSql.join(", ");
+        ctxValues.length = currentValuesLen;
+        batch = pushOrNewArray(batch, {
+          text: ctx.sql.join(" "),
+          values: ctxValues
+        });
+        ctxValues = ctx.values = [];
+        valuesSql.length = 0;
+        i--;
+      } else {
+        currentValuesLen = ctxValues.length;
+        valuesSql.push(encodedRow);
+      }
+    }
+    if (batch) {
+      ctx.sql[1] = (inCTE ? "SELECT " : "VALUES ") + valuesSql.join(", ");
+      batch.push({
+        text: ctx.sql.join(" "),
+        values: ctxValues
+      });
+      return {
+        hookSelect: returning.hookSelect,
+        batch
+      };
+    } else {
+      ctx.sql[1] = (inCTE ? "SELECT " : "VALUES ") + valuesSql.join(", ");
+    }
+    if (inCTE) {
+      ctx.sql[1] += ' WHERE NOT EXISTS (SELECT 1 FROM "f")';
+    }
+  } else if (query.kind === "raw") {
+    if (isExpression(values)) {
+      let valuesSql = values.toSQL(ctx, quotedAs);
+      if (runtimeDefaults) {
+        valuesSql += `, ${runtimeDefaults.map((fn) => addValue(ctx.values, fn())).join(", ")}`;
+      }
+      ctx.sql[1] = `VALUES (${valuesSql})`;
+    } else {
+      let sql;
+      if (runtimeDefaults) {
+        const { values: v } = ctx;
+        sql = values.map(
+          (raw) => (
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            `(${raw.toSQL(ctx, quotedAs)}, ${runtimeDefaults.map((fn) => addValue(v, fn())).join(", ")})`
+          )
+        ).join(", ");
+      } else {
+        sql = values.map((raw) => `(${raw.toSQL(ctx, quotedAs)})`).join(", ");
+      }
+      ctx.sql[1] = `VALUES ${sql}`;
+    }
+  } else {
+    const { from, values: v } = values;
+    const q2 = from.clone();
+    if (v) {
+      pushQueryValue(
+        q2,
+        "select",
+        new RawSQL(
+          encodeRow(
+            ctx,
+            ctx.values,
+            q2,
+            QueryClass,
+            v[0],
+            runtimeDefaults,
+            quotedAs
+          )
+        )
+      );
+    }
+    ctx.sql[1] = getSqlText(makeSQL(q2, { values: ctx.values }));
+  }
+  return {
+    hookSelect: returning.hookSelect,
+    text: ctx.sql.join(" "),
+    values: ctx.values
+  };
+};
+const mergeColumnsSql = (columns, quotedColumns2, target, except) => {
+  const notExcluded = [];
+  const exclude = typeof target === "string" ? [target] : Array.isArray(target) ? [...target] : [];
+  if (except) {
+    if (typeof except === "string") {
+      exclude.push(except);
+    } else {
+      exclude.push(...except);
+    }
+  }
+  for (let i = 0; i < columns.length; i++) {
+    if (!exclude.includes(columns[i])) {
+      notExcluded.push(quotedColumns2[i]);
+    }
+  }
+  return notExcluded.length ? `DO UPDATE SET ${notExcluded.map((column) => `${column} = excluded.${column}`).join(", ")}` : "DO NOTHING";
+};
+const encodeRow = (ctx, values, q, QueryClass, row, runtimeDefaults, quotedAs) => {
+  const arr = row.map((value) => {
+    if (value && typeof value === "object") {
+      if (value instanceof Expression) {
+        return value.toSQL(ctx, quotedAs);
+      } else if (value instanceof QueryClass) {
+        return `(${getSqlText(joinSubQuery(q, value).toSQL(ctx))})`;
+      }
+    }
+    return value === void 0 ? "DEFAULT" : addValue(values, value);
+  });
+  if (runtimeDefaults) {
+    for (const fn of runtimeDefaults) {
+      arr.push(addValue(values, fn()));
+    }
+  }
+  return arr.join(", ");
+};
+const hookSelectKeys = [
+  null,
+  "afterUpdateSelect",
+  "afterCreateSelect",
+  "afterDeleteSelect"
+];
+const makeReturningSql = (ctx, q, data, quotedAs, hookSelectI, addHookSelectI) => {
+  if (data.inCTE) {
+    if (hookSelectI !== 2) {
+      const returning = makeReturningSql(
+        ctx,
+        q,
+        data,
+        quotedAs,
+        2,
+        hookSelectI
+      );
+      if (returning.hookSelect) {
+        for (const [key, value] of returning.hookSelect) {
+          data.inCTE.targetHookSelect.set(key, value);
+        }
+      }
+      return data.inCTE.returning = returning;
+    }
+    if (data.inCTE.returning) {
+      return data.inCTE.returning;
+    }
+  }
+  const hookSelect = hookSelectI && data[hookSelectKeys[hookSelectI]];
+  const { select } = data;
+  if (!q.q.hookSelect && !hookSelect?.size && !select?.length && !addHookSelectI) {
+    return { hookSelect: hookSelect && /* @__PURE__ */ new Map() };
+  }
+  const otherCTEHookSelect = addHookSelectI && data[hookSelectKeys[addHookSelectI]];
+  let tempSelect;
+  if (q.q.hookSelect || hookSelect || otherCTEHookSelect) {
+    tempSelect = new Map(q.q.hookSelect);
+    if (hookSelect) {
+      for (const column of hookSelect) {
+        tempSelect.set(column, { select: column });
+      }
+    }
+    if (otherCTEHookSelect) {
+      for (const column of otherCTEHookSelect) {
+        tempSelect.set(column, { select: column });
+      }
+    }
+  }
+  let sql;
+  if (tempSelect?.size || select?.length) {
+    sql = selectToSql(ctx, q, data, quotedAs, tempSelect, void 0, true);
+  } else if (addHookSelectI) {
+    sql = "1";
+  }
+  return { select: sql, hookSelect: tempSelect };
+};
+
 const pushSelectSql = (ctx, table, query, quotedAs, aliases) => {
   const sql = selectToSql(
     ctx,
@@ -5659,7 +5978,16 @@ const pushSelectSql = (ctx, table, query, quotedAs, aliases) => {
   );
   if (sql) ctx.sql.push(sql);
 };
-const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect, aliases) => {
+const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect, aliases, skipCTE) => {
+  if (query.inCTE && !skipCTE) {
+    const { select } = makeReturningSql(
+      ctx,
+      table,
+      query,
+      quotedAs
+    );
+    return query.inCTE.selectNum ? select ? "0, " + select : "0" : select || "";
+  }
   let selected;
   const list = [];
   if (query.select) {
@@ -6003,371 +6331,116 @@ const pushFromAndAs = (ctx, table, data, quotedAs) => {
     let fn;
     let query;
     if ("query" in source) {
-      fn = "websearch_to_tsquery";
-      query = source.query;
-    } else if ("plainQuery" in source) {
-      fn = "plainto_tsquery";
-      query = source.plainQuery;
-    } else if ("phraseQuery" in source) {
-      fn = "phraseto_tsquery";
-      query = source.phraseQuery;
-    } else {
-      fn = "to_tsquery";
-      query = source.tsQuery;
-    }
-    let querySql;
-    if (typeof query === "string") {
-      ctx.values.push(query);
-      querySql = `$${ctx.values.length}`;
-    } else {
-      querySql = `${query.toSQL(ctx, quotedAs)}`;
-    }
-    sql += `, ${fn}(${lang}, ${querySql}) "${as}"`;
-  }
-  ctx.sql.push(sql);
-};
-const getFrom = (ctx, table, data, quotedAs) => {
-  if (data.from) {
-    const { from } = data;
-    if (Array.isArray(from)) {
-      return from.map((item) => fromToSql(ctx, data, item, quotedAs)).join(", ");
-    }
-    return fromToSql(ctx, data, from, quotedAs);
-  }
-  let sql = quoteSchemaAndTable(data.schema, table.table);
-  if (data.only) sql = `ONLY ${sql}`;
-  return sql;
-};
-const fromToSql = (ctx, data, from, quotedAs) => {
-  let only;
-  let sql;
-  if (typeof from === "object") {
-    if (isExpression(from)) {
-      sql = from.toSQL(ctx, quotedAs);
-    } else {
-      only = from.q.only;
-      if (!from.table) {
-        sql = `(${getSqlText(makeSQL(from, ctx))})`;
-      } else if (!checkIfASimpleQuery(from)) {
-        sql = `(${getSqlText(makeSQL(from, ctx))})`;
-      } else {
-        sql = quoteSchemaAndTable(from.q.schema, from.table);
-      }
-    }
-  } else {
-    sql = quoteSchemaAndTable(data.schema, from);
-  }
-  return (only === void 0 ? data.only : only) ? `ONLY ${sql}` : sql;
-};
-const getSearchLang = (ctx, data, source, quotedAs) => {
-  return source.langSQL ?? (source.langSQL = "languageColumn" in source ? columnToSql(ctx, data, data.shape, source.languageColumn, quotedAs) : isRawSQL(source.language) ? source.language.toSQL(ctx) : addValue(ctx.values, source.language || data.language || "english"));
-};
-const getSearchText = (ctx, data, source, quotedAs, forHeadline) => {
-  let sql = source.textSQL;
-  if (sql) return sql;
-  if ("in" in source) {
-    if (typeof source.in === "string") {
-      sql = columnToSql(ctx, data, data.shape, source.in, quotedAs);
-    } else if (Array.isArray(source.in)) {
-      sql = `concat_ws(' ', ${source.in.map((column) => columnToSql(ctx, data, data.shape, column, quotedAs)).join(", ")})`;
-    } else {
-      sql = [];
-      for (const key in source.in) {
-        sql.push(columnToSql(ctx, data, data.shape, key, quotedAs));
-      }
-    }
-  } else if ("vector" in source) {
-    if (forHeadline) {
-      throw new Error(
-        "Cannot use a search based on a vector column for a search headline"
-      );
-    }
-    sql = columnToSql(ctx, data, data.shape, source.vector, quotedAs);
-  } else {
-    if (typeof source.text === "string") {
-      sql = addValue(ctx.values, source.text);
-    } else {
-      sql = source.text.toSQL(ctx, quotedAs);
-    }
-  }
-  return source.textSQL = sql;
-};
-const getTsVector = (ctx, data, lang, source, quotedAs) => {
-  const text = getSearchText(ctx, data, source, quotedAs);
-  if ("in" in source) {
-    if (typeof source.in === "string" || Array.isArray(source.in)) {
-      return `to_tsvector(${lang}, ${text})`;
-    } else {
-      let tsVector = "";
-      let i = 0;
-      for (const key in source.in) {
-        tsVector = (tsVector ? `${tsVector} || ` : "") + `setweight(to_tsvector(${lang}, ${text[i++]}), ${addValue(
-          ctx.values,
-          source.in[key]
-        )})`;
-      }
-      return tsVector;
-    }
-  } else if ("vector" in source) {
-    return text;
-  } else {
-    return `to_tsvector(${lang}, ${text})`;
-  }
-};
-
-const MAX_BINDING_PARAMS = 65536;
-
-const quotedColumns = [];
-const makeInsertSql = (ctx, q, query, quotedAs) => {
-  const { columns, shape } = query;
-  quotedColumns.length = columns.length;
-  for (let i = 0, len = columns.length; i < len; i++) {
-    quotedColumns[i] = `"${shape[columns[i]]?.data.name || columns[i]}"`;
-  }
-  let runtimeDefaults;
-  if (q.internal.runtimeDefaultColumns) {
-    runtimeDefaults = [];
-    for (const key of q.internal.runtimeDefaultColumns) {
-      if (!columns.includes(key)) {
-        const column = shape[key];
-        quotedColumns.push(`"${column.data.name || key}"`);
-        runtimeDefaults.push(column.data.runtimeDefault);
-      }
-    }
-  }
-  let values = query.values;
-  if (quotedColumns.length === 0) {
-    const key = Object.keys(q.shape)[0];
-    const column = q.shape[key];
-    quotedColumns[0] = `"${column?.data.name || key}"`;
-    if (Array.isArray(values) && Array.isArray(values[0])) {
-      values = values.map(() => [void 0]);
-    }
-  }
-  ctx.sql.push(
-    `INSERT INTO ${quotedAs}(${quotedColumns.join(", ")})`,
-    null
-  );
-  const QueryClass = ctx.queryBuilder.constructor;
-  if (query.onConflict) {
-    ctx.sql.push("ON CONFLICT");
-    const { target } = query.onConflict;
-    if (target) {
-      if (typeof target === "string") {
-        ctx.sql.push(`("${shape[target]?.data.name || target}")`);
-      } else if (Array.isArray(target)) {
-        ctx.sql.push(
-          `(${target.reduce(
-            (sql, item, i) => sql + (i ? ", " : "") + `"${shape[item]?.data.name || item}"`,
-            ""
-          )})`
-        );
-      } else if ("toSQL" in target) {
-        ctx.sql.push(target.toSQL(ctx, quotedAs));
-      } else {
-        ctx.sql.push(`ON CONSTRAINT "${target.constraint}"`);
-      }
-    }
-    if ("merge" in query.onConflict) {
-      let sql;
-      const { merge } = query.onConflict;
-      if (merge) {
-        if (typeof merge === "string") {
-          const name = shape[merge]?.data.name || merge;
-          sql = `DO UPDATE SET "${name}" = excluded."${name}"`;
-        } else if ("except" in merge) {
-          sql = mergeColumnsSql(columns, quotedColumns, target, merge.except);
-        } else {
-          sql = `DO UPDATE SET ${merge.reduce((sql2, item, i) => {
-            const name = shape[item]?.data.name || item;
-            return sql2 + (i ? ", " : "") + `"${name}" = excluded."${name}"`;
-          }, "")}`;
-        }
-      } else {
-        sql = mergeColumnsSql(columns, quotedColumns, target);
-      }
-      ctx.sql.push(sql);
-    } else if (query.onConflict.set) {
-      let sql;
-      const { set } = query.onConflict;
-      if (isExpression(set)) {
-        sql = set.toSQL(ctx, quotedAs);
-      } else {
-        const arr = [];
-        for (const key in set) {
-          arr.push(
-            `"${shape[key]?.data.name || key}" = ${addValue(
-              ctx.values,
-              set[key]
-            )}`
-          );
-        }
-        sql = arr.join(", ");
-      }
-      ctx.sql.push("DO UPDATE SET", sql);
+      fn = "websearch_to_tsquery";
+      query = source.query;
+    } else if ("plainQuery" in source) {
+      fn = "plainto_tsquery";
+      query = source.plainQuery;
+    } else if ("phraseQuery" in source) {
+      fn = "phraseto_tsquery";
+      query = source.phraseQuery;
     } else {
-      ctx.sql.push("DO NOTHING");
-    }
-  }
-  pushWhereStatementSql(ctx, q, query, quotedAs);
-  const hookSelect = pushReturningSql(
-    ctx,
-    q,
-    query,
-    quotedAs,
-    query.afterCreateSelect
-  );
-  if (query.kind === "object") {
-    const valuesSql = [];
-    let ctxValues = ctx.values;
-    const restValuesLen = ctxValues.length;
-    let currentValuesLen = restValuesLen;
-    let batch;
-    for (let i = 0; i < values.length; i++) {
-      const encodedRow = `(${encodeRow(
-        ctx,
-        ctxValues,
-        q,
-        QueryClass,
-        values[i],
-        runtimeDefaults,
-        quotedAs
-      )})`;
-      if (ctxValues.length > MAX_BINDING_PARAMS) {
-        if (ctxValues.length - currentValuesLen > MAX_BINDING_PARAMS) {
-          throw new Error(
-            `Too many parameters for a single insert row, max is ${MAX_BINDING_PARAMS}`
-          );
-        }
-        ctx.sql[1] = `VALUES ${valuesSql.join(",")}`;
-        ctxValues.length = currentValuesLen;
-        batch = pushOrNewArray(batch, {
-          text: ctx.sql.join(" "),
-          values: ctxValues
-        });
-        ctxValues = ctx.values = [];
-        valuesSql.length = 0;
-        i--;
-      } else {
-        currentValuesLen = ctxValues.length;
-        valuesSql.push(encodedRow);
-      }
+      fn = "to_tsquery";
+      query = source.tsQuery;
     }
-    if (batch) {
-      ctx.sql[1] = `VALUES ${valuesSql.join(",")}`;
-      batch.push({
-        text: ctx.sql.join(" "),
-        values: ctxValues
-      });
-      return {
-        hookSelect,
-        batch
-      };
+    let querySql;
+    if (typeof query === "string") {
+      ctx.values.push(query);
+      querySql = `$${ctx.values.length}`;
     } else {
-      ctx.sql[1] = `VALUES ${valuesSql.join(", ")}`;
+      querySql = `${query.toSQL(ctx, quotedAs)}`;
     }
-  } else if (query.kind === "raw") {
-    if (isExpression(values)) {
-      let valuesSql = values.toSQL(ctx, quotedAs);
-      if (runtimeDefaults) {
-        valuesSql += `, ${runtimeDefaults.map((fn) => addValue(ctx.values, fn())).join(", ")}`;
-      }
-      ctx.sql[1] = `VALUES (${valuesSql})`;
+    sql += `, ${fn}(${lang}, ${querySql}) "${as}"`;
+  }
+  ctx.sql.push(sql);
+};
+const getFrom = (ctx, table, data, quotedAs) => {
+  if (data.from) {
+    const { from } = data;
+    if (Array.isArray(from)) {
+      return from.map((item) => fromToSql(ctx, data, item, quotedAs)).join(", ");
+    }
+    return fromToSql(ctx, data, from, quotedAs);
+  }
+  let sql = quoteSchemaAndTable(data.schema, table.table);
+  if (data.only) sql = `ONLY ${sql}`;
+  return sql;
+};
+const fromToSql = (ctx, data, from, quotedAs) => {
+  let only;
+  let sql;
+  if (typeof from === "object") {
+    if (isExpression(from)) {
+      sql = from.toSQL(ctx, quotedAs);
     } else {
-      let sql;
-      if (runtimeDefaults) {
-        const { values: v } = ctx;
-        sql = values.map(
-          (raw) => (
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            `(${raw.toSQL(ctx, quotedAs)}, ${runtimeDefaults.map((fn) => addValue(v, fn())).join(", ")})`
-          )
-        ).join(", ");
+      only = from.q.only;
+      if (!from.table) {
+        sql = `(${getSqlText(makeSQL(from, ctx))})`;
+      } else if (!checkIfASimpleQuery(from)) {
+        sql = `(${getSqlText(makeSQL(from, ctx))})`;
       } else {
-        sql = values.map((raw) => `(${raw.toSQL(ctx, quotedAs)})`).join(", ");
+        sql = quoteSchemaAndTable(from.q.schema, from.table);
       }
-      ctx.sql[1] = `VALUES ${sql}`;
     }
   } else {
-    const { from, values: v } = values;
-    const q2 = from.clone();
-    if (v) {
-      pushQueryValue(
-        q2,
-        "select",
-        new RawSQL(
-          encodeRow(
-            ctx,
-            ctx.values,
-            q2,
-            QueryClass,
-            v[0],
-            runtimeDefaults,
-            quotedAs
-          )
-        )
-      );
-    }
-    ctx.sql[1] = getSqlText(makeSQL(q2, { values: ctx.values }));
+    sql = quoteSchemaAndTable(data.schema, from);
   }
-  return {
-    hookSelect,
-    text: ctx.sql.join(" "),
-    values: ctx.values
-  };
+  return (only === void 0 ? data.only : only) ? `ONLY ${sql}` : sql;
 };
-const mergeColumnsSql = (columns, quotedColumns2, target, except) => {
-  const notExcluded = [];
-  const exclude = typeof target === "string" ? [target] : Array.isArray(target) ? [...target] : [];
-  if (except) {
-    if (typeof except === "string") {
-      exclude.push(except);
-    } else {
-      exclude.push(...except);
-    }
-  }
-  for (let i = 0; i < columns.length; i++) {
-    if (!exclude.includes(columns[i])) {
-      notExcluded.push(quotedColumns2[i]);
-    }
-  }
-  return notExcluded.length ? `DO UPDATE SET ${notExcluded.map((column) => `${column} = excluded.${column}`).join(", ")}` : "DO NOTHING";
+const getSearchLang = (ctx, data, source, quotedAs) => {
+  return source.langSQL ?? (source.langSQL = "languageColumn" in source ? columnToSql(ctx, data, data.shape, source.languageColumn, quotedAs) : isRawSQL(source.language) ? source.language.toSQL(ctx) : addValue(ctx.values, source.language || data.language || "english"));
 };
-const encodeRow = (ctx, values, q, QueryClass, row, runtimeDefaults, quotedAs) => {
-  const arr = row.map((value) => {
-    if (value && typeof value === "object") {
-      if (value instanceof Expression) {
-        return value.toSQL(ctx, quotedAs);
-      } else if (value instanceof QueryClass) {
-        return `(${getSqlText(joinSubQuery(q, value).toSQL(ctx))})`;
+const getSearchText = (ctx, data, source, quotedAs, forHeadline) => {
+  let sql = source.textSQL;
+  if (sql) return sql;
+  if ("in" in source) {
+    if (typeof source.in === "string") {
+      sql = columnToSql(ctx, data, data.shape, source.in, quotedAs);
+    } else if (Array.isArray(source.in)) {
+      sql = `concat_ws(' ', ${source.in.map((column) => columnToSql(ctx, data, data.shape, column, quotedAs)).join(", ")})`;
+    } else {
+      sql = [];
+      for (const key in source.in) {
+        sql.push(columnToSql(ctx, data, data.shape, key, quotedAs));
       }
     }
-    return value === void 0 ? "DEFAULT" : addValue(values, value);
-  });
-  if (runtimeDefaults) {
-    for (const fn of runtimeDefaults) {
-      arr.push(addValue(values, fn()));
+  } else if ("vector" in source) {
+    if (forHeadline) {
+      throw new Error(
+        "Cannot use a search based on a vector column for a search headline"
+      );
+    }
+    sql = columnToSql(ctx, data, data.shape, source.vector, quotedAs);
+  } else {
+    if (typeof source.text === "string") {
+      sql = addValue(ctx.values, source.text);
+    } else {
+      sql = source.text.toSQL(ctx, quotedAs);
     }
   }
-  return arr.join(", ");
+  return source.textSQL = sql;
 };
-const pushReturningSql = (ctx, q, data, quotedAs, hookSelect, keyword = "RETURNING") => {
-  const { select } = data;
-  if (!hookSelect?.size && !select) return hookSelect && /* @__PURE__ */ new Map();
-  ctx.sql.push(keyword);
-  if (q.q.hookSelect || hookSelect) {
-    const tempSelect = new Map(q.q.hookSelect);
-    if (hookSelect) {
-      for (const column of hookSelect) {
-        tempSelect.set(column, { select: column });
+const getTsVector = (ctx, data, lang, source, quotedAs) => {
+  const text = getSearchText(ctx, data, source, quotedAs);
+  if ("in" in source) {
+    if (typeof source.in === "string" || Array.isArray(source.in)) {
+      return `to_tsvector(${lang}, ${text})`;
+    } else {
+      let tsVector = "";
+      let i = 0;
+      for (const key in source.in) {
+        tsVector = (tsVector ? `${tsVector} || ` : "") + `setweight(to_tsvector(${lang}, ${text[i++]}), ${addValue(
+          ctx.values,
+          source.in[key]
+        )})`;
       }
+      return tsVector;
     }
-    ctx.sql.push(selectToSql(ctx, q, data, quotedAs, tempSelect));
-    return tempSelect;
-  } else if (select) {
-    ctx.sql.push(selectToSql(ctx, q, data, quotedAs));
+  } else if ("vector" in source) {
+    return text;
+  } else {
+    return `to_tsvector(${lang}, ${text})`;
   }
-  return;
 };
 
 const pushUpdateSql = (ctx, table, query, quotedAs) => {
@@ -6378,12 +6451,11 @@ const pushUpdateSql = (ctx, table, query, quotedAs) => {
     if (!query.select) {
       query.select = countSelect;
     }
-    const hookSelect = pushReturningSql(
+    const hookSelect = pushUpdateReturning(
       ctx,
       table,
       query,
       quotedAs,
-      query.afterUpdateSelect,
       "SELECT"
     );
     ctx.sql.push(`FROM ${quotedTable}`);
@@ -6398,7 +6470,21 @@ const pushUpdateSql = (ctx, table, query, quotedAs) => {
   ctx.sql.push("SET");
   ctx.sql.push(set.join(", "));
   pushWhereStatementSql(ctx, table, query, quotedAs);
-  return pushReturningSql(ctx, table, query, quotedAs, query.afterUpdateSelect);
+  return pushUpdateReturning(ctx, table, query, quotedAs, "RETURNING");
+};
+const pushUpdateReturning = (ctx, table, query, quotedAs, keyword) => {
+  const { inCTE } = query;
+  const { select, hookSelect } = makeReturningSql(
+    ctx,
+    table,
+    query,
+    quotedAs,
+    1,
+    inCTE && 2
+  );
+  const s = inCTE?.selectNum ? select ? "0, " + select : "0" : select;
+  if (s) ctx.sql.push(keyword, s);
+  return hookSelect;
 };
 const processData = (ctx, table, set, data, quotedAs) => {
   let append;
@@ -6481,7 +6567,9 @@ const pushDeleteSql = (ctx, table, query, quotedAs) => {
       ctx.sql.push("WHERE", conditions);
     }
   }
-  return pushReturningSql(ctx, table, query, quotedAs, query.afterDeleteSelect);
+  const returning = makeReturningSql(ctx, table, query, quotedAs, 3);
+  if (returning.select) ctx.sql.push("RETURNING", returning.select);
+  return returning.hookSelect;
 };
 
 const pushTruncateSql = (ctx, table, query) => {
@@ -6560,7 +6648,7 @@ const makeSQL = (table, options) => {
   if (query.with) {
     pushWithSql(ctx, query.with);
   }
-  if (query.type) {
+  if (query.type && query.type !== "upsert") {
     const tableName = table.table ?? query.as;
     if (!tableName) throw new Error(`Table is missing for ${query.type}`);
     if (query.type === "truncate") {
@@ -6596,10 +6684,11 @@ const makeSQL = (table, options) => {
   }
   const quotedAs = (query.as || table.table) && `"${query.as || table.table}"`;
   if (query.union) {
-    sql.push(`(${getSqlText(makeSQL(query.union.b, { values }))})`);
+    const s = getSqlText(makeSQL(query.union.b, { values }));
+    sql.push(query.union.p ? s : `(${s})`);
     for (const u of query.union.u) {
-      const itemSql = isExpression(u.a) ? u.a.toSQL(ctx, quotedAs) : getSqlText(makeSQL(u.a, { values }));
-      sql.push(`${u.k} (${itemSql})`);
+      const s2 = isExpression(u.a) ? u.a.toSQL(ctx, quotedAs) : getSqlText(makeSQL(u.a, { values }));
+      sql.push(`${u.k} ${u.p ? s2 : "(" + s2 + ")"}`);
     }
   } else {
     sql.push("SELECT");
@@ -9985,12 +10074,13 @@ class MergeQueryMethods {
   }
 }
 
-const _queryUnion = (base, args, k) => {
+const _queryUnion = (base, args, k, p, m) => {
   const q = base.baseQuery.clone();
   const u = args.map(
     (a) => ({
       a: typeof a === "function" ? a(q) : a,
-      k
+      k,
+      m
     })
   );
   const union = q.q.union = base.q.union;
@@ -9999,7 +10089,8 @@ const _queryUnion = (base, args, k) => {
   } else {
     q.q.union = {
       b: base,
-      u
+      u,
+      p
     };
   }
   return q;
@@ -10277,7 +10368,7 @@ const _queryUpdate = (query, arg) => {
   }
   const { queries } = ctx;
   if (queries) {
-    q.patchResult = async (_, queryResult) => {
+    q.patchResult = async (_, _h, queryResult) => {
       await Promise.all(queries.map(callWithThis, queryResult));
       if (ctx.collect) {
         const t = query.baseQuery.clone();
@@ -10866,26 +10957,80 @@ class SearchMethods {
 
 function orCreate(query, data, updateData, mergeData) {
   const { q } = query;
-  q.returnType = "one";
-  q.wrapInTransaction = true;
+  q.returnsOne = true;
+  if (!q.select) {
+    q.returnType = "void";
+  }
   const { handleResult } = q;
   let result;
   let created = false;
   q.handleResult = (q2, t, r, s) => {
     return created ? result : handleResult(q2, t, r, s);
   };
-  q.patchResult = async (q2, queryResult) => {
+  q.hookSelect ?? (q.hookSelect = /* @__PURE__ */ new Map());
+  q.patchResult = async (q2, hookSelect, queryResult) => {
+    var _a, _b;
     if (queryResult.rowCount === 0) {
       if (typeof data === "function") {
         data = data(updateData);
       }
       if (mergeData) data = { ...mergeData, ...data };
-      const inner = q2.create(data);
-      inner.q.handleResult = (q3, t, r, s) => {
-        result = handleResult(q3, t, r, s);
-        return inner.q.hookSelect ? result.map((row) => ({ ...row })) : result;
+      let hasAfterCallback = q2.q.afterCreate;
+      let hasAfterCommitCallback = q2.q.afterCreateCommit;
+      if (updateData) {
+        hasAfterCallback = hasAfterCallback || q2.q.afterUpdate;
+        hasAfterCommitCallback = hasAfterCommitCallback || q2.q.afterUpdateCommit;
+      }
+      const inCTE = {
+        selectNum: !!(hasAfterCallback || hasAfterCommitCallback),
+        targetHookSelect: hookSelect
       };
-      await inner;
+      q2 = q2.clone();
+      q2.q.inCTE = inCTE;
+      const c = q2.create(data);
+      c.q.select = q2.q.select;
+      let q22 = q2.queryBuilder.with("f", q2).with("c", c);
+      q22.q.returnsOne = true;
+      queryFrom(q22, "f");
+      q22 = _queryUnion(
+        q22,
+        [q2.queryBuilder.from("c")],
+        "UNION ALL",
+        true,
+        true
+      );
+      let afterHooks;
+      let afterCommitHooks;
+      q22.q.handleResult = (a, t, r, s) => {
+        if (hasAfterCallback || hasAfterCommitCallback) {
+          const fieldName = r.fields[0].name;
+          if (r.rows[0][fieldName]) {
+            afterHooks = q2.q.afterCreate;
+            afterCommitHooks = q2.q.afterCreateCommit;
+          } else {
+            afterHooks = q2.q.afterUpdate;
+            afterCommitHooks = q2.q.afterUpdateCommit;
+          }
+          delete r.rows[0][fieldName];
+        }
+        result = handleResult(a, t, r, s);
+        return a.q.hookSelect ? result.map((row) => ({ ...row })) : result;
+      };
+      q22.q.log = q2.q.log;
+      q22.q.logger = q2.q.logger;
+      q22.q.type = "upsert";
+      q22.q.beforeCreate = q2.q.beforeCreate;
+      if (hasAfterCallback) {
+        ((_a = q22.q).afterCreate ?? (_a.afterCreate = [])).push(
+          (data2, query2) => afterHooks && Promise.all([...afterHooks].map((fn) => fn(data2, query2)))
+        );
+      }
+      if (hasAfterCommitCallback) {
+        ((_b = q22.q).afterCreateCommit ?? (_b.afterCreateCommit = [])).push(
+          (data2, query2) => afterCommitHooks && Promise.all([...afterCommitHooks].map((fn) => fn(data2, query2)))
+        );
+      }
+      await q22;
       created = true;
     } else if (queryResult.rowCount > 1) {
       throw new MoreThanOneRowError(
@@ -10898,9 +11043,7 @@ function orCreate(query, data, updateData, mergeData) {
 }
 class QueryUpsertOrCreate {
   /**
-   * `upsert` tries to update one record, and it will perform create in case a record was not found.
-   *
-   * It will implicitly wrap queries in a transaction if it was not wrapped yet.
+   * `upsert` tries to update a single record, and then it creates the record if it doesn't yet exist.
    *
    * `find` or `findBy` must precede `upsert` because it does not work with multiple updates.
    *
@@ -10911,7 +11054,7 @@ class QueryUpsertOrCreate {
    *
    * `data` and `update` objects are of the same type that's expected by `update` method, `create` object is of type of `create` method argument.
    *
-   * It is not returning a value by default, place `select` or `selectAll` before `upsert` to specify returning columns.
+   * No values are returned by default, place `select` or `selectAll` before `upsert` to specify returning columns.
    *
    * ```ts
    * await User.selectAll()
@@ -10988,6 +11131,9 @@ class QueryUpsertOrCreate {
    *   });
    * ```
    *
+   * `upsert` works in the exact same way as [orCreate](#orCreate), but with `UPDATE` statement instead of `SELECT`.
+   * it also performs a single query if the record exists, and two queries if there is no record yet.
+   *
    * @param data - `update` property for the data to update, `create` property for the data to create
    */
   upsert(data) {
@@ -11002,22 +11148,16 @@ class QueryUpsertOrCreate {
     if (!isObjectEmpty(updateData)) {
       _queryUpdate(q, updateData);
     }
-    const c = orCreate(q, data.create, updateData, mergeData);
-    if (!c.q.select) {
-      c.q.returnType = "void";
-    }
-    return c;
+    return orCreate(q, data.create, updateData, mergeData);
   }
   /**
    * `orCreate` creates a record only if it was not found by conditions.
    *
-   * It will implicitly wrap queries in a transaction if it was not wrapped yet.
-   *
    * `find` or `findBy` must precede `orCreate`.
    *
    * It is accepting the same argument as `create` commands.
    *
-   * By default, it is not returning columns, place `get`, `select`, or `selectAll` before `orCreate` to specify returning columns.
+   * No result is returned by default, place `get`, `select`, or `selectAll` before `orCreate` to specify returning columns.
    *
    * ```ts
    * const user = await User.selectAll()
@@ -11028,7 +11168,7 @@ class QueryUpsertOrCreate {
    *   });
    * ```
    *
-   * The data may be returned from a function, it won't be called if the record was found:
+   * The data can be returned from a function, it won't be called if the record was found:
    *
    * ```ts
    * const user = await User.selectAll()
@@ -11039,6 +11179,35 @@ class QueryUpsertOrCreate {
    *   }));
    * ```
    *
+   * `orCreate` works by performing just a single query in the case if the record exists, and one additional query when the record does not exist.
+   *
+   * At first, it performs a "find" query, the query cost is exact same as if you didn't use `orCreate`.
+   *
+   * Then, if the record wasn't found, it performs a single query with CTE expressions to try finding it again, for the case it was already created just a moment before,
+   * and then it creates the record if it's still not found. Using such CTE allows to skip using transactions, while still conforming to atomicity.
+   *
+   * ```sql
+   * -- first query
+   * SELECT * FROM "table" WHERE "key" = 'value'
+   *
+   * -- the record could have been created in between these two queries
+   *
+   * -- second query
+   * WITH find_row AS (
+   *   SELECT * FROM "table" WHERE "key" = 'value'
+   * )
+   * WITH insert_row AS (
+   *   INSERT INTO "table" ("key")
+   *   SELECT 'value'
+   *   -- skip the insert if the row already exists
+   *   WHERE NOT EXISTS (SELECT 1 FROM find_row)
+   *   RETURNING *
+   * )
+   * SELECT * FROM find_row
+   * UNION ALL
+   * SELECT * FROM insert_row
+   * ```
+   *
    * @param data - the same data as for `create`, it may be returned from a callback
    */
   orCreate(data) {
@@ -11277,16 +11446,17 @@ class ColumnRefExpression extends Expression {
   }
 }
 class RefExpression extends Expression {
-  constructor(value, q, ref) {
+  constructor(value, query, ref) {
     super();
-    this.q = q;
     this.ref = ref;
     this.result = { value };
-    q.expr = this;
+    (this.q = query.q).expr = this;
+    this.table = query.table;
     Object.assign(this, value.operators);
   }
-  makeSQL(ctx, quotedAs) {
-    return columnToSql(ctx, this.q, this.q.shape, this.ref, quotedAs);
+  makeSQL(ctx) {
+    const as = this.q.as || this.table;
+    return columnToSql(ctx, this.q, this.q.shape, this.ref, as && `"${as}"`);
   }
 }
 class OrExpression extends Expression {
@@ -11382,7 +11552,7 @@ class ExpressionMethods {
     } else {
       column = shape[arg];
     }
-    return new RefExpression(column, q.q, arg);
+    return new RefExpression(column, q, arg);
   }
   val(value) {
     return new ValExpression(value);
@@ -12097,6 +12267,9 @@ class QueryMethods {
   narrowType() {
     return () => this;
   }
+  if(condition, fn) {
+    return condition ? fn(this) : this;
+  }
   queryRelated(relName, params) {
     return this.relations[relName].relationConfig.queryRelated(
       params