pqb 0.56.3 → 0.56.5

package/dist/index.js

@@ -4235,14 +4235,7 @@ const throwIfJoinLateral = (q, method) => {
 };
 const saveAliasedShape = (q, as, key) => {
   const shapes = q.q[key];
-  if (shapes?.[as]) {
-    let suffix = 2;
-    let name;
-    while (shapes[name = `${as}${suffix}`]) {
-      suffix++;
-    }
-    as = name;
-  }
+  as = orchidCore.getFreeAlias(shapes, as);
   setQueryObjectValueImmutable(q, key, as, orchidCore.emptyObject);
   return as;
 };
@@ -6354,15 +6347,26 @@ const pushWithSql = (ctx, items) => {
   const sql = withToSql(ctx, items);
   if (sql) ctx.sql.push("WITH", sql);
 };
+const pushOrAppendWithSql = (ctx, query, items) => {
+  const sql = withToSql(ctx, items);
+  if (sql) {
+    if (query.with) {
+      ctx.sql[ctx.sql.length - 1] += ",";
+    } else {
+      ctx.sql.push("WITH");
+    }
+    ctx.sql.push(sql);
+  }
+};
 
 const makeInsertSql = (ctx, q, query, quotedAs) => {
   let { columns } = query;
   const { shape, inCTE, hookCreateSet } = query;
   const QueryClass = ctx.qb.constructor;
-  let values = query.values;
+  let { insertFrom, queryColumnsCount, values } = query;
   let hookSetSql;
   if (hookCreateSet) {
-    ({ hookSetSql, columns, values } = processHookSet(
+    ({ hookSetSql, columns, insertFrom, queryColumnsCount, values } = processHookSet(
       ctx,
       q,
       values,
@@ -6381,6 +6385,7 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     for (const key of q.internal.runtimeDefaultColumns) {
       if (!columns.includes(key)) {
         const column = shape[key];
+        columns.push(key);
         quotedColumns.push(`"${column.data.name || key}"`);
         runtimeDefaults.push(column.data.runtimeDefault);
       }
@@ -6398,8 +6403,22 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
   }
   const insertSql = `INSERT INTO ${quotedAs}${quotedColumns.length ? "(" + quotedColumns.join(", ") + ")" : ""}`;
   const hasNonSelect = ctx.hasNonSelect;
-  if ("from" in values && query.insertWith) {
-    pushWithSql(ctx, Object.values(query.insertWith).flat());
+  let hasWith = !!query.with;
+  if (insertFrom) {
+    if (values.length < 2) {
+      if (query.insertWith) {
+        hasWith = true;
+        pushOrAppendWithSql(ctx, query, Object.values(query.insertWith).flat());
+      }
+    } else {
+      hasWith = true;
+      pushOrAppendWithSql(ctx, query, [
+        {
+          n: getQueryAs(insertFrom),
+          q: insertFrom
+        }
+      ]);
+    }
   }
   const valuesPos = ctx.sql.length + 1;
   ctx.sql.push(insertSql, null);
@@ -6475,28 +6494,38 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     );
   }
   if (returning.select) ctx.sql.push("RETURNING", returning.select);
-  if ("from" in values) {
-    const { from, values: v } = values;
-    const q2 = from.clone();
-    if (v) {
-      orchidCore.pushQueryValueImmutable(
-        q2,
-        "select",
-        new RawSQL(
-          encodeRow(
-            ctx,
-            ctx.values,
-            q2,
-            QueryClass,
-            v,
-            runtimeDefaults,
-            quotedAs
+  let insertManyFromValuesAs;
+  if (insertFrom) {
+    if (values.length < 2) {
+      const q2 = insertFrom.clone();
+      if (values[0]?.length) {
+        orchidCore.pushQueryValueImmutable(
+          q2,
+          "select",
+          new RawSQL(
+            encodeRow(
+              ctx,
+              ctx.values,
+              q2,
+              QueryClass,
+              values[0],
+              runtimeDefaults,
+              quotedAs
+            )
           )
-        )
-      );
+        );
+      }
+      ctx.sql[valuesPos] = getSqlText(toSQL(q2, ctx));
+    } else {
+      insertManyFromValuesAs = query.insertValuesAs;
+      const queryAs = getQueryAs(insertFrom);
+      ctx.sql[valuesPos - 1] += ` SELECT "${queryAs}".*, ${columns.slice(queryColumnsCount || 0).map((key) => {
+        const column = shape[key];
+        return column ? `${insertManyFromValuesAs}."${column.data.name || key}"::${column.dataType}` : `${insertManyFromValuesAs}."${key}"`;
+      }).join(", ")} FROM "${queryAs}",`;
     }
-    ctx.sql[valuesPos] = getSqlText(toSQL(q2, ctx));
-  } else {
+  }
+  if (!insertFrom || insertManyFromValuesAs) {
     const valuesSql = [];
     let ctxValues = ctx.values;
     const restValuesLen = ctxValues.length;
@@ -6505,6 +6534,8 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     const { insertWith } = query;
     const { skipBatchCheck } = ctx;
     const withSqls = [];
+    const startingKeyword = (insertManyFromValuesAs ? "(" : "") + (inCTE ? "SELECT " : "VALUES ");
+    const valuesAppend = insertManyFromValuesAs ? `) ${insertManyFromValuesAs}(${quotedColumns.slice(queryColumnsCount || 0).join(", ")})` : "";
     for (let i = 0; i < values.length; i++) {
       const withes = insertWith?.[i];
       ctx.skipBatchCheck = true;
@@ -6528,11 +6559,8 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
           );
         }
         if (!skipBatchCheck) {
-          if (withSqls.length) {
-            ctx.sql[valuesPos - 1] = "WITH " + withSqls.join(", ") + " " + insertSql;
-            withSqls.length = 0;
-          }
-          ctx.sql[valuesPos] = (inCTE ? "SELECT " : "VALUES ") + valuesSql.join(", ");
+          addWithSqls(ctx, hasWith, withSqls, valuesPos, insertSql);
+          ctx.sql[valuesPos] = startingKeyword + valuesSql.join(", ") + valuesAppend;
           ctxValues.length = currentValuesLen;
           batch = orchidCore.pushOrNewArray(batch, {
             text: ctx.sql.join(" "),
@@ -6548,9 +6576,7 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
       if (withSql) withSqls.push(withSql);
       valuesSql.push(encodedRow);
     }
-    if (withSqls.length) {
-      ctx.sql[valuesPos - 1] = "WITH " + withSqls.join(", ") + " " + insertSql;
-    }
+    addWithSqls(ctx, hasWith, withSqls, valuesPos, insertSql);
     if (batch) {
       if (hasNonSelect) {
         throw new orchidCore.OrchidOrmInternalError(
@@ -6558,7 +6584,7 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
           `Cannot insert many records when having a non-select sub-query`
         );
       }
-      ctx.sql[valuesPos] = (inCTE ? "SELECT " : "VALUES ") + valuesSql.join(", ");
+      ctx.sql[valuesPos] = startingKeyword + valuesSql.join(", ") + valuesAppend;
       batch.push({
         text: ctx.sql.join(" "),
         values: ctxValues
@@ -6569,7 +6595,7 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
         batch
       };
     } else {
-      ctx.sql[valuesPos] = (inCTE ? "SELECT " : "VALUES ") + valuesSql.join(", ");
+      ctx.sql[valuesPos] = startingKeyword + valuesSql.join(", ") + valuesAppend;
     }
     if (inCTE) {
       ctx.sql[valuesPos] += ' WHERE NOT EXISTS (SELECT 1 FROM "f")';
@@ -6582,6 +6608,15 @@ const makeInsertSql = (ctx, q, query, quotedAs) => {
     values: ctx.values
   };
 };
+const addWithSqls = (ctx, hasWith, withSqls, valuesPos, insertSql) => {
+  if (withSqls.length) {
+    if (hasWith) {
+      ctx.sql[valuesPos - 2] += ",";
+    }
+    ctx.sql[valuesPos - 1] = (hasWith ? "" : "WITH ") + withSqls.join(", ") + " " + insertSql;
+    withSqls.length = 0;
+  }
+};
 const processHookSet = (ctx, q, values, hookCreateSet, columns, QueryClass, quotedAs) => {
   const hookSet = {};
   for (const item of hookCreateSet) {
@@ -6590,48 +6625,54 @@ const processHookSet = (ctx, q, values, hookCreateSet, columns, QueryClass, quot
   const addHookSetColumns = Object.keys(hookSet).filter(
     (key) => !columns.includes(key)
   );
-  if ("from" in values) {
-    const v = { ...values };
-    const newColumns = [];
-    const originalSelect = v.from.q.select;
+  let insertFrom = q.q.insertFrom;
+  if (insertFrom) {
+    const newColumns = /* @__PURE__ */ new Set();
+    const originalSelect = insertFrom.q.select;
     if (originalSelect) {
-      v.from = _clone(v.from);
+      insertFrom = _clone(insertFrom);
       const select = [];
       for (const s of originalSelect) {
         if (typeof s === "string" && !hookSet[s]) {
           select.push(s);
-          newColumns.push(s);
+          newColumns.add(s);
         } else if (typeof s === "object" && "selectAs" in s) {
           const filtered = {};
           for (const key in s.selectAs) {
             if (!hookSet[key]) {
               filtered[key] = s.selectAs[key];
-              newColumns.push(key);
+              newColumns.add(key);
             }
           }
           select.push({ selectAs: filtered });
         }
       }
-      v.from.q.select = select;
-    }
-    let row;
-    if (v.values) {
-      const originalRow = v.values;
-      const valuesColumns = columns.slice(-originalRow.length);
-      row = [];
-      valuesColumns.forEach((c, i) => {
-        if (!hookSet[c]) {
-          newColumns.push(c);
-          row.push(originalRow[i]);
-        }
+      insertFrom.q.select = select;
+    }
+    if (values.length) {
+      const newValues = [];
+      const valuesColumnsSet = /* @__PURE__ */ new Set();
+      values.forEach((originalRow, i) => {
+        const valuesColumns = columns.slice(-originalRow.length);
+        const row = [];
+        newValues[i] = row;
+        valuesColumns.forEach((c, i2) => {
+          if (!hookSet[c] && !newColumns.has(c)) {
+            valuesColumnsSet.add(c);
+            row.push(originalRow[i2]);
+          }
+        });
       });
+      for (const valueColumn of valuesColumnsSet) {
+        newColumns.add(valueColumn);
+      }
+      values = newValues;
     } else {
-      row = [];
+      values = [[]];
     }
-    v.values = row;
     columns.forEach((column) => {
       if (column in hookSet) {
-        newColumns.push(column);
+        newColumns.add(column);
         const fromHook = {
           fromHook: encodeValue(
             ctx,
@@ -6642,28 +6683,35 @@ const processHookSet = (ctx, q, values, hookCreateSet, columns, QueryClass, quot
             quotedAs
           )
         };
-        row.push(fromHook);
+        for (const row of values) {
+          row.push(fromHook);
+        }
       }
     });
+    const queryColumnsCount = insertFrom.q.select?.length;
     if (addHookSetColumns) {
       for (const key of addHookSetColumns) {
-        row.push({
-          fromHook: encodeValue(
-            ctx,
-            ctx.values,
-            q,
-            QueryClass,
-            hookSet[key],
-            quotedAs
-          )
-        });
+        for (const row of values) {
+          row.push({
+            fromHook: encodeValue(
+              ctx,
+              ctx.values,
+              q,
+              QueryClass,
+              hookSet[key],
+              quotedAs
+            )
+          });
+        }
       }
       return {
         columns: [...newColumns, ...addHookSetColumns],
-        values: v
+        insertFrom,
+        queryColumnsCount,
+        values
       };
     }
-    return { columns: newColumns, values: v };
+    return { columns: [...newColumns], insertFrom, queryColumnsCount, values };
   }
   columns.forEach((column, i) => {
     if (column in hookSet) {
@@ -6979,8 +7027,7 @@ const selectToSql = (ctx, table, query, quotedAs, hookSelect = query.hookSelect,
           hookSelect.delete(column);
           continue;
         }
-        let i = 2;
-        while (selected[name = `${column}${i}`]) i++;
+        name = orchidCore.getFreeAlias(selected, column);
         item.as = name;
         item.temp = name;
         sql += ` "${name}"`;
@@ -8623,7 +8670,7 @@ class Union {
   }
 }
 
-const addWith = (q, withStore, item, key = "with") => {
+const _addWith = (query, withStore, item, key = "with") => {
   if (item.q) {
     item.q.q.with?.forEach((item2, i, arr) => {
       if (item2?.q?.q.type) {
@@ -8634,7 +8681,8 @@ const addWith = (q, withStore, item, key = "with") => {
     if (item.q.q.insertWith) {
       const values = Object.values(item.q.q.insertWith).flat();
       item.q.q.insertWith = void 0;
-      q.q.with = q.q.with ? [...q.q.with, ...values] : values;
+      const { q } = query;
+      q.with = q.with ? [...q.with, ...values] : values;
     }
   }
   orchidCore.pushOrNewArrayToObjectImmutable(withStore, key, item);
@@ -8642,7 +8690,7 @@ const addWith = (q, withStore, item, key = "with") => {
 const moveQueryValueToWith = (q, withStore, value, withKey, set, key) => {
   if (value.q.type) {
     const as = saveAliasedShape(q, "q", "withShapes");
-    addWith(
+    _addWith(
       q,
       withStore,
       {
@@ -8676,7 +8724,7 @@ class WithMethods {
         columns: Object.keys(query.shape)
       };
     }
-    addWith(q, q.q, { n: name, o: options, q: query });
+    _addWith(q, q.q, { n: name, o: options, q: query });
     const shape = getShapeFromSelect(query, true);
     return setQueryObjectValueImmutable(q, "withShapes", name, {
       shape,
@@ -8702,7 +8750,7 @@ class WithMethods {
         columns: Object.keys(shape)
       };
     }
-    addWith(q, q.q, { n: name, o: options, q: query });
+    _addWith(q, q.q, { n: name, o: options, q: query });
     return setQueryObjectValueImmutable(q, "withShapes", name, withConfig);
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -8720,6 +8768,248 @@ class WithMethods {
   }
 }
 
+const insertFrom = (query, from, many, queryMany, data) => {
+  const ctx = createCtx();
+  const obj = data && (Array.isArray(data) ? handleManyData(query, data, ctx) : handleOneData(query, data, ctx));
+  return insert(
+    query,
+    {
+      insertFrom: from,
+      columns: obj?.columns || [],
+      values: obj?.values || []
+    },
+    many,
+    queryMany
+  );
+};
+const getFromSelectColumns = (q, from, obj, many) => {
+  if (!many && !queryTypeWithLimitOne[from.q.returnType]) {
+    throw new Error(
+      "Cannot create based on a query which returns multiple records"
+    );
+  }
+  const queryColumns = /* @__PURE__ */ new Set();
+  from.q.select?.forEach((item) => {
+    if (typeof item === "string") {
+      const index = item.indexOf(".");
+      queryColumns.add(index === -1 ? item : item.slice(index + 1));
+    } else if (item && "selectAs" in item) {
+      for (const column in item.selectAs) {
+        queryColumns.add(column);
+      }
+    }
+  });
+  const allColumns = new Set(queryColumns);
+  const queryColumnsCount = queryColumns.size;
+  const allValues = [];
+  if (obj?.columns) {
+    for (const objectValues of obj.values) {
+      const values = [];
+      allValues.push(values);
+      obj.columns.forEach((column, i) => {
+        if (!queryColumns.has(column)) {
+          allColumns.add(column);
+          values.push(objectValues[i]);
+        }
+      });
+    }
+  }
+  for (const key of queryColumns) {
+    const column = q.shape[key];
+    if (column) throwOnReadOnly$1(from, column, key);
+  }
+  return {
+    columns: [...allColumns],
+    queryColumnsCount,
+    values: allValues
+  };
+};
+const _queryCreateOneFrom = (q, query, data) => {
+  createSelect(q);
+  return insertFrom(q, query, false, false, data);
+};
+const _queryInsertOneFrom = (q, query, data) => {
+  return insertFrom(q, query, false, false, data);
+};
+const _queryCreateManyFrom = (q, query, data) => {
+  createSelect(q);
+  return insertFrom(q, query, true, false, data);
+};
+const _queryInsertManyFrom = (q, query, data) => {
+  return insertFrom(q, query, true, false, data);
+};
+const _queryCreateForEachFrom = (q, query) => {
+  createSelect(q);
+  return insertFrom(q, query, true, true);
+};
+const _queryInsertForEachFrom = (q, query) => {
+  return insertFrom(q, query, true, true);
+};
+class QueryCreateFrom {
+  /**
+   * Inserts a single record based on a query that selects a single record.
+   *
+   * Performs a single SQL query based on `INSERT ... SELECT ... FROM`.
+   *
+   * See {@link createManyFrom} to insert multiple records based on a single record query,
+   * and {@link createForEachFrom} to insert a record per every one found by the query.
+   *
+   * The first argument is a query of a **single** record, it should have `find`, `take`, or similar.
+   *
+   * The second optional argument is a data which will be merged with columns returned by the query.
+   *
+   * The data for the second argument is the same as in {@link create}.
+   *
+   * Columns with runtime defaults (defined with a callback) are supported here.
+   * The value for such a column will be injected unless selected from a related table or provided in a data object.
+   *
+   * ```ts
+   * const oneRecord = await db.table.createOneFrom(
+   *   db.relatedTable
+   *     // use select to map columns from one table to another
+   *     .select({
+   *       // relatedTable's id will be inserted as "relatedId"
+   *       relatedId: 'id',
+   *     })
+   *     .findBy({ key: 'value' }),
+   *   // optional argument:
+   *   {
+   *     key: 'value',
+   *     // supports sql, nested select, create, update, delete queries
+   *     fromSql: () => sql`custom sql`,
+   *     fromQuery: () => db.otherTable.find(id).update(data).get('column'),
+   *     fromRelated: (q) => q.relatedTable.create(data).get('column'),
+   *   },
+   * );
+   * ```
+   *
+   * The query above will produce such a SQL (omitting `from*` values):
+   *
+   * ```sql
+   * INSERT INTO "table"("relatedId", "key")
+   * SELECT "relatedTable"."id" AS "relatedId", 'value'
+   * FROM "relatedTable"
+   * WHERE "relatedTable"."key" = 'value'
+   * LIMIT 1
+   * RETURNING *
+   * ```
+   *
+   * @param query - query to create new records from
+   * @param data - additionally you can set some columns
+   */
+  createOneFrom(query, data) {
+    return _queryCreateOneFrom(_clone(this), query, data);
+  }
+  /**
+   * Works exactly as {@link createOneFrom}, except that it returns inserted row count by default.
+   *
+   * @param query - query to create new records from
+   * @param data - additionally you can set some columns
+   */
+  insertOneFrom(query, data) {
+    return _queryInsertOneFrom(_clone(this), query, data);
+  }
+  /**
+   * Inserts multiple records based on a query that selects a single record.
+   *
+   * Performs a single SQL query based on `INSERT ... SELECT ... FROM`.
+   *
+   * See {@link createOneFrom} to insert a single record based on a single record query,
+   * and {@link createForEachFrom} to insert a record per every one found by the query.
+   *
+   * The first argument is a query of a **single** record, it should have `find`, `take`, or similar.
+   *
+   * The second argument is array of objects to be merged with columns returned by the query.
+   *
+   * The data for the second argument is the same as in {@link createMany}.
+   *
+   * Columns with runtime defaults (defined with a callback) are supported here.
+   * The value for such a column will be injected unless selected from a related table or provided in a data object.
+   *
+   * ```ts
+   * const twoRecords = await db.table.createManyFrom(
+   *   db.relatedTable
+   *     // use select to map columns from one table to another
+   *     .select({
+   *       // relatedTable's id will be inserted as "relatedId"
+   *       relatedId: 'id',
+   *     })
+   *     .findBy({ key: 'value' }),
+   *   [
+   *     {
+   *       key: 'value 1',
+   *       // supports sql, nested select, create, update, delete queries
+   *       fromSql: () => sql`custom sql`,
+   *       fromQuery: () => db.otherTable.find(id).update(data).get('column'),
+   *       fromRelated: (q) => q.relatedTable.create(data).get('column'),
+   *     },
+   *     {
+   *       key: 'value 2',
+   *     },
+   *   ],
+   * );
+   * ```
+   *
+   * The query above will produce such a SQL (omitting `from*` values):
+   *
+   * ```sql
+   * WITH "relatedTable" AS (
+   *   SELECT "relatedTable"."id" AS "relatedId", 'value'
+   *   FROM "relatedTable"
+   *   WHERE "relatedTable"."key" = 'value'
+   *   LIMIT 1
+   * )
+   * INSERT INTO "table"("relatedId", "key")
+   * SELECT "relatedTable".*, v."key"::text
+   * FROM "relatedTable", (VALUES ('value1'), ('value2')) v("key")
+   * RETURNING *
+   * ```
+   *
+   * @param query - query to create new records from
+   * @param data - array of records to create
+   */
+  createManyFrom(query, data) {
+    return _queryCreateManyFrom(_clone(this), query, data);
+  }
+  /**
+   * Works exactly as {@link createManyFrom}, except that it returns inserted row count by default.
+   *
+   * @param query - query to create new records from
+   * @param data - array of records to create
+   */
+  insertManyFrom(query, data) {
+    return _queryInsertManyFrom(_clone(this), query, data);
+  }
+  /**
+   * Inserts a single record per every record found in a given query.
+   *
+   * Performs a single SQL query based on `INSERT ... SELECT ... FROM`.
+   *
+   * Unlike {@link createOneFrom}, it doesn't accept second argument with data.
+   *
+   * Runtime defaults cannot work with it.
+   *
+   * ```ts
+   * const manyRecords = await db.table.createForEachFrom(
+   *   RelatedTable.select({ relatedId: 'id' }).where({ key: 'value' }),
+   * );
+   * ```
+   *
+   * @param query - query to create new records from
+   */
+  createForEachFrom(query) {
+    return _queryCreateForEachFrom(_clone(this), query);
+  }
+  /**
+   * Works exactly as {@link createForEachFrom}, except that it returns inserted row count by default.
+   *
+   * @param query - query to create new records from
+   */
+  insertForEachFrom(query) {
+    return _queryInsertForEachFrom(_clone(this), query);
+  }
+}
+
 const createSelect = (q) => {
   if (q.q.returnType === "void" || isSelectingCount(q)) {
     q.q.select = void 0;
@@ -8818,8 +9108,9 @@ const handleManyData = (q, data, ctx) => {
 };
 const insert = (self, {
   columns,
+  insertFrom,
   values
-}, many) => {
+}, many, queryMany) => {
   const { q } = self;
   if (!q.select?.length) {
     q.returning = true;
@@ -8828,6 +9119,28 @@ const insert = (self, {
   delete q.or;
   delete q.scopes;
   q.type = "insert";
+  insertFrom = insertFrom ? q.insertFrom = insertFrom : q.insertFrom;
+  if (insertFrom) {
+    if (q.insertFrom) {
+      const obj = getFromSelectColumns(
+        self,
+        q.insertFrom,
+        {
+          columns,
+          values
+        },
+        queryMany
+      );
+      columns = obj.columns;
+      values = obj.values;
+      q.queryColumnsCount = obj.queryColumnsCount;
+    }
+    if (values.length > 1) {
+      const insertValuesAs = orchidCore._getQueryFreeAlias(q, "v");
+      orchidCore._setQueryAlias(self, "v", insertValuesAs);
+      q.insertValuesAs = insertValuesAs;
+    }
+  }
   q.columns = columns;
   q.values = values;
   const { select, returnType } = q;
@@ -8843,63 +9156,20 @@ const insert = (self, {
       q.returnType = "pluck";
     }
   } else if (!returnType || returnType === "all") {
-    q.returnType = "from" in values ? values.from.q.returnType : "one";
+    q.returnType = insertFrom ? insertFrom.q.returnType : "one";
   } else if (returnType === "pluck") {
     q.returnType = "valueOrThrow";
   }
   return self;
 };
-const getFromSelectColumns = (q, from, obj, many) => {
-  if (!many && !queryTypeWithLimitOne[from.q.returnType]) {
-    throw new Error(
-      "Cannot create based on a query which returns multiple records"
-    );
-  }
-  const queryColumns = [];
-  from.q.select?.forEach((item) => {
-    if (typeof item === "string") {
-      const index = item.indexOf(".");
-      queryColumns.push(index === -1 ? item : item.slice(index + 1));
-    } else if (item && "selectAs" in item) {
-      queryColumns.push(...Object.keys(item.selectAs));
-    }
-  });
-  if (obj?.columns) {
-    queryColumns.push(...obj.columns);
-  }
-  for (const key of queryColumns) {
-    const column = q.shape[key];
-    if (column) throwOnReadOnly$1(from, column, key);
-  }
-  return queryColumns;
-};
-const insertFromQuery = (q, from, many, data) => {
-  const ctx = createCtx();
-  const obj = data && handleOneData(q, data, ctx);
-  const columns = getFromSelectColumns(q, from, obj, many);
-  return insert(
-    q,
-    {
-      columns,
-      values: { from, values: obj?.values[0] }
-    },
-    many
-  );
-};
 const _queryCreate = (q, data) => {
   createSelect(q);
   return _queryInsert(q, data);
 };
-const _queryInsert = (q, data) => {
+const _queryInsert = (query, data) => {
   const ctx = createCtx();
-  const obj = handleOneData(q, data, ctx);
-  const values = q.q.values;
-  if (values && "from" in values) {
-    obj.columns = getFromSelectColumns(q, values.from, obj);
-    values.values = obj.values[0];
-    obj.values = values;
-  }
-  return insert(q, obj);
+  const obj = handleOneData(query, data, ctx);
+  return insert(query, obj);
 };
 const _queryCreateMany = (q, data) => {
   createSelect(q);
@@ -8911,20 +9181,6 @@ const _queryInsertMany = (q, data) => {
   if (!data.length) result = result.none();
   return result;
 };
-const _queryCreateFrom = (q, query, data) => {
-  createSelect(q);
-  return insertFromQuery(q, query, false, data);
-};
-const _queryInsertFrom = (q, query, data) => {
-  return insertFromQuery(q, query, false, data);
-};
-const _queryCreateManyFrom = (q, query) => {
-  createSelect(q);
-  return insertFromQuery(q, query, true);
-};
-const _queryInsertManyFrom = (q, query) => {
-  return insertFromQuery(q, query, true);
-};
 const _queryDefaults = (q, data) => {
   q.q.defaults = data;
   return q;
@@ -9042,85 +9298,6 @@ class QueryCreate {
   insertMany(data) {
     return _queryInsertMany(_clone(this), data);
   }
-  /**
-   * These methods are for creating a single record, for batch creating see {@link createManyFrom}.
-   *
-   * `createFrom` is to perform the `INSERT ... SELECT ...` SQL statement, it does select and insert by performing a single query.
-   *
-   * The first argument is a query for a **single** record, it should have `find`, `take`, or similar.
-   *
-   * The second optional argument is a data which will be merged with columns returned from the select query.
-   *
-   * The data for the second argument is the same as in {@link create}.
-   *
-   * Columns with runtime defaults (defined with a callback) are supported here.
-   * The value for such a column will be injected unless selected from a related table or provided in a data object.
-   *
-   * ```ts
-   * const oneRecord = await db.table.createFrom(
-   *   // In the select, key is a related table column, value is a column to insert as
-   *   RelatedTable.select({ relatedId: 'id' }).findBy({ key: 'value' }),
-   *   // optional argument:
-   *   {
-   *     key: 'value',
-   *     // supports sql, nested select, create, update, delete queries
-   *     fromSql: () => sql`custom sql`,
-   *     fromQuery: () => db.otherTable.find(id).update(data).get('column'),
-   *     fromRelated: (q) => q.relatedTable.create(data).get('column'),
-   *   },
-   * );
-   * ```
-   *
-   * The query above will produce such SQL:
-   *
-   * ```sql
-   * INSERT INTO "table"("relatedId", "key")
-   * SELECT "relatedTable"."id" AS "relatedId", 'value'
-   * FROM "relatedTable"
-   * WHERE "relatedTable"."key" = 'value'
-   * LIMIT 1
-   * RETURNING *
-   * ```
-   *
-   * @param query - query to create new records from
-   * @param data - additionally you can set some columns
-   */
-  createFrom(query, data) {
-    return _queryCreateFrom(_clone(this), query, data);
-  }
-  /**
-   * Works exactly as {@link createFrom}, except that it returns inserted row count by default.
-   *
-   * @param query - query to create new records from
-   * @param data - additionally you can set some columns
-   */
-  insertFrom(query, data) {
-    return _queryInsertFrom(_clone(this), query, data);
-  }
-  /**
-   * Similar to `createFrom`, but intended to create many records.
-   *
-   * Unlike `createFrom`, it doesn't accept second argument with data, and runtime defaults cannot work with it.
-   *
-   * ```ts
-   * const manyRecords = await db.table.createManyFrom(
-   *   RelatedTable.select({ relatedId: 'id' }).where({ key: 'value' }),
-   * );
-   * ```
-   *
-   * @param query - query to create new records from
-   */
-  createManyFrom(query) {
-    return _queryCreateManyFrom(_clone(this), query);
-  }
-  /**
-   * Works exactly as {@link createManyFrom}, except that it returns inserted row count by default.
-   *
-   * @param query - query to create new records from
-   */
-  insertManyFrom(query) {
-    return _queryInsertManyFrom(_clone(this), query);
-  }
   /**
    * `defaults` allows setting values that will be used later in `create`.
    *
@@ -10505,9 +10682,9 @@ class Join {
   }
   /**
    * This method may be useful
-   * for combining with [createManyFrom](/guide/create-update-delete.html#createmanyfrom-insertmanyfrom).
+   * for combining with [createForEachFrom](/guide/create-update-delete.html#createForEachFrom-insertForEachFrom).
    *
-   * `createManyFrom` creates multiple record based on a selecting query:
+   * `createForEachFrom` creates multiple record based on a selecting query:
    *
    * ```sql
    * INSERT INTO t1(c1, c2)
@@ -10521,7 +10698,7 @@ class Join {
    * ```ts
    * const data = [{ column2: 'one' }, { column2: 'two' }, { column2: 'three' }];
    *
-   * await db.table.createManyFrom(
+   * await db.table.createForEachFrom(
    *   db.otherTable
    *     .joinData('data', (t) => ({ column2: t.text() }), data)
    *     .select('otherTable.column1', 'data.column2'),
@@ -12618,6 +12795,7 @@ orchidCore.applyMixins(QueryMethods, [
   Union,
   JsonMethods,
   QueryCreate,
+  QueryCreateFrom,
   Update,
   Delete,
   Transaction,
@@ -13307,7 +13485,6 @@ exports.MergeQueryMethods = MergeQueryMethods;
 exports.MoneyColumn = MoneyColumn;
 exports.NumberAsStringBaseColumn = NumberAsStringBaseColumn;
 exports.NumberBaseColumn = NumberBaseColumn;
-exports.OnConflictQueryBuilder = OnConflictQueryBuilder;
 exports.OnMethods = OnMethods;
 exports.Operators = Operators;
 exports.OrExpression = OrExpression;
@@ -13316,7 +13493,6 @@ exports.PointColumn = PointColumn;
 exports.PolygonColumn = PolygonColumn;
 exports.PostgisGeographyPointColumn = PostgisGeographyPointColumn;
 exports.QueryAsMethods = QueryAsMethods;
-exports.QueryCreate = QueryCreate;
 exports.QueryGet = QueryGet;
 exports.QueryHooks = QueryHooks;
 exports.QueryLog = QueryLog;
@@ -13351,6 +13527,7 @@ exports.VirtualColumn = VirtualColumn;
 exports.Where = Where;
 exports.WithMethods = WithMethods;
 exports.XMLColumn = XMLColumn;
+exports._addWith = _addWith;
 exports._clone = _clone;
 exports._getSelectableColumn = _getSelectableColumn;
 exports._initQueryBuilder = _initQueryBuilder;
@@ -13358,9 +13535,10 @@ exports._queryAfterSaveCommit = _queryAfterSaveCommit;
 exports._queryAll = _queryAll;
 exports._queryChangeCounter = _queryChangeCounter;
 exports._queryCreate = _queryCreate;
-exports._queryCreateFrom = _queryCreateFrom;
+exports._queryCreateForEachFrom = _queryCreateForEachFrom;
 exports._queryCreateMany = _queryCreateMany;
 exports._queryCreateManyFrom = _queryCreateManyFrom;
+exports._queryCreateOneFrom = _queryCreateOneFrom;
 exports._queryDefaults = _queryDefaults;
 exports._queryDelete = _queryDelete;
 exports._queryExec = _queryExec;
@@ -13382,9 +13560,10 @@ exports._queryHookBeforeQuery = _queryHookBeforeQuery;
 exports._queryHookBeforeSave = _queryHookBeforeSave;
 exports._queryHookBeforeUpdate = _queryHookBeforeUpdate;
 exports._queryInsert = _queryInsert;
-exports._queryInsertFrom = _queryInsertFrom;
+exports._queryInsertForEachFrom = _queryInsertForEachFrom;
 exports._queryInsertMany = _queryInsertMany;
 exports._queryInsertManyFrom = _queryInsertManyFrom;
+exports._queryInsertOneFrom = _queryInsertOneFrom;
 exports._queryJoinOn = _queryJoinOn;
 exports._queryJoinOnJsonPathEquals = _queryJoinOnJsonPathEquals;
 exports._queryJoinOrOn = _queryJoinOrOn;