orchid-orm 1.77.3 → 1.78.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { DynamicRawSQL, QueryHooks, RawSql, VirtualColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _onUpsertUpdate, _orCreate, _prependWith, _prependWithOnUpsertCreate, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertMany, _queryInsertManyFrom, _queryJoinOn, _queryRows, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, applyMixins, cloneQueryBaseUnscoped, defaultSchemaConfig, emptyArray, emptyObject, getCallerFilePath, getClonedQueryData, getColumnTypes, getForeignKeyTableInstance, getFreeAlias, getPrimaryKeys, getQueryAs, getShapeFromSelect, getStackTrace, internalSchemaConfig, isExpression, isQueryReturnsAll, makeColumnTypes, noop, objectHasValues, parseTableData, parseTableDataInput, pick, prepareSubQueryForSql, pushQueryOnForOuter, setQueryObjectValueImmutable, tableDataMethods, toArray, toSnakeCase } from "pqb/internal";
+import { DynamicRawSQL, QueryHooks, RawSql, VirtualColumn, _appendQuery, _appendQueryOnUpsertCreate, _clone, _createDbSqlMethod, _hookSelectColumns, _initQueryBuilder, _onUpsertUpdate, _orCreate, _prependWith, _prependWithOnUpsertCreate, _queryCreate, _queryCreateMany, _queryCreateManyFrom, _queryDefaults, _queryDelete, _queryFindBy, _queryFindByOptional, _queryHookAfterCreate, _queryHookAfterUpdate, _queryInsert, _queryInsertForEachFrom, _queryInsertMany, _queryInsertManyFrom, _queryJoinOn, _querySelect, _queryTake, _queryTakeOptional, _queryUpdate, _queryUpdateOrThrow, _queryUpsert, _queryWhere, _queryWhereExists, _queryWhereIn, applyMixins, cloneQueryBaseUnscoped, defaultSchemaConfig, emptyArray, emptyObject, getCallerFilePath, getClonedQueryData, getColumnTypes, getForeignKeyTableInstance, getFreeAlias, getPrimaryKeys, getQueryAs, getShapeFromSelect, getStackTrace, internalSchemaConfig, isExpression, isQueryReturnsAll, makeColumnTypes, noop, objectHasValues, parseTableData, parseTableDataInput, prepareSubQueryForSql, pushQueryOnForOuter, setQueryObjectValueImmutable, tableDataMethods, toArray, toSnakeCase } from "pqb/internal";
 import { Db, NotFoundError, OrchidOrmInternalError } from "pqb";
 import { AsyncLocalStorage } from "node:async_hooks";
 export * from "pqb";
@@ -587,6 +587,21 @@ const makeNestedUpdateUpsertData = (upsert, setIds) => ({
 		...setIds
 	}
 });
+const makeRawSqlPlaceholders = (length) => {
+	return Array.from({ length }, () => new RawSql(""));
+};
+const makeRawSqlPlaceholderRecord = (keys) => {
+	const placeholders = makeRawSqlPlaceholders(keys.length);
+	const record = {};
+	for (let i = 0; i < keys.length; i++) record[keys[i]] = placeholders[i];
+	return record;
+};
+const setRawSqlPlaceholdersFromCte = (placeholders, cte, primaryKeys, rowIndex, count) => {
+	for (let i = 0; i < placeholders.length; i++) placeholders[i]._sql = selectCteColumnFromManySql(cte, primaryKeys[i], rowIndex, count);
+};
+const setRawSqlPlaceholderRecordFromCte = (record, keys, cte, primaryKeys, rowIndex, count) => {
+	setRawSqlPlaceholdersFromCte(keys.map((key) => record[key]), cte, primaryKeys, rowIndex, count);
+};
 const getThroughRelation = (table, through) => {
 	return table.relations[through];
 };
@@ -597,7 +612,7 @@ const hasRelationHandleCreate = (q, ctx, items, rowIndexes, key, primaryKeys, ne
 	q.q.wrapInTransaction = true;
 	items.forEach((item, i) => {
 		const value = item[key];
-		if ((!value.create || Array.isArray(value.create) && value.create.length === 0) && (!value.connect || Array.isArray(value.connect) && value.connect.length === 0) && (!value.connectOrCreate || Array.isArray(value.connectOrCreate) && value.connectOrCreate.length === 0)) return;
+		if ((!value.create || Array.isArray(value.create) && value.create.length === 0) && (!value.connect || Array.isArray(value.connect) && value.connect.length === 0) && (!value.connectOrCreate || Array.isArray(value.connectOrCreate) && value.connectOrCreate.length === 0) && (!("upsert" in value) || !value.upsert || Array.isArray(value.upsert) && value.upsert.length === 0)) return;
 		const store = ctx;
 		if (!store.hasRelation) store.hasRelation = {};
 		const values = [rowIndexes[i], value];
@@ -610,14 +625,6 @@ const hasRelationHandleCreate = (q, ctx, items, rowIndexes, key, primaryKeys, ne
 		_queryHookAfterCreate(q, primaryKeys, (rows, q) => nestedInsert(q, relationData.map(([rowIndex, data]) => [rows[rowIndex], data])));
 	});
 };
-const hasRelationHandleUpdate = (q, set, key, primaryKeys, nestedUpdate) => {
-	const value = set[key];
-	if (!value.set && !("upsert" in value) && (!value.add || Array.isArray(value.add) && value.add.length === 0) && (!value.disconnect || Array.isArray(value.disconnect) && value.disconnect.length === 0) && (!value.delete || Array.isArray(value.delete) && value.delete.length === 0) && (!value.update || Array.isArray(value.update.where) && value.update.where.length === 0) && (!value.create || Array.isArray(value.create) && value.create.length === 0)) return;
-	q.q.wrapInTransaction = true;
-	_queryHookAfterUpdate(q, primaryKeys, (rows, q) => {
-		return nestedUpdate(q, rows, value);
-	});
-};
 function joinHasThrough(q, baseQuery, joiningQuery, throughRelation, sourceRelation) {
 	return q.whereExists(throughRelation.joinQuery(throughRelation.query, baseQuery), (() => {
 		const as = getQueryAs(joiningQuery);
@@ -683,17 +690,17 @@ const getColumnKeyFromDbName = (query, name) => {
 	for (const k in query.shape) if (query.shape[k].data.name === name) return k;
 	return name;
 };
-const selectCteColumnsSql$1 = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
-const selectCteColumnSql$1 = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
+const selectCteColumnsSql = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
+const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
 const makeNestedUpdateRelationIds = (q, relQuery, primaryKeys, foreignKeys) => {
 	const selectIdsSql = new RawSql("");
 	const setIds = {};
 	for (const foreignKey of foreignKeys) setIds[foreignKey] = new RawSql("");
 	let appendedAs;
 	_hookSelectColumns(q, primaryKeys, (aliasedPrimaryKeys) => {
-		selectIdsSql._sql = selectCteColumnsSql$1(appendedAs, aliasedPrimaryKeys);
+		selectIdsSql._sql = selectCteColumnsSql(appendedAs, aliasedPrimaryKeys);
 		foreignKeys.forEach((foreignKey, i) => {
-			setIds[foreignKey]._sql = selectCteColumnSql$1(appendedAs, aliasedPrimaryKeys[i]);
+			setIds[foreignKey]._sql = selectCteColumnSql(appendedAs, aliasedPrimaryKeys[i]);
 		});
 	});
 	return {
@@ -713,8 +720,8 @@ const selectCteColumnFromManySql = (cteAs, column, rowIndex, count) => {
 	return sql + ")";
 };
 const selectCteColumnMustExistSql = (i, cteAs, column) => {
-	const selectColumn = selectCteColumnSql$1(cteAs, column);
-	return i === 0 ? `CASE WHEN (SELECT count(*) FROM "${cteAs}") = 0 AND (SELECT 'not-found')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn;
+	const selectColumn = selectCteColumnSql(cteAs, column);
+	return i === 0 ? `CASE WHEN (SELECT count(*) FROM "${cteAs}") = 0 AND (SELECT ':not-found:1:0')::int = 0 THEN NULL ELSE ${selectColumn} END` : selectColumn;
 };
 const setForeignKeysFromCte = (record, primaryKeys, foreignKeys, mustExist) => {
 	for (const key of foreignKeys) record[key] = new RawSql("");
@@ -722,7 +729,7 @@ const setForeignKeysFromCte = (record, primaryKeys, foreignKeys, mustExist) => {
 		foreignKeys.forEach(mustExist ? (foreignKey, i) => {
 			record[foreignKey]._sql = selectCteColumnMustExistSql(i, as, primaryKeys[i]);
 		} : (foreignKey, i) => {
-			record[foreignKey]._sql = selectCteColumnSql$1(as, primaryKeys[i]);
+			record[foreignKey]._sql = selectCteColumnSql(as, primaryKeys[i]);
 		});
 	};
 };
@@ -803,7 +810,7 @@ const belongsToCreate = (key, state, q, ctx, items) => {
 	let nestedCreateItems;
 	items.forEach((item) => {
 		const value = item[key];
-		const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
+		const kind = value.create ? "create" : value.connect ? "connect" : value.connectOrCreate ? "connectOrCreate" : void 0;
 		if (kind) {
 			const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
 				items: [],
@@ -811,7 +818,7 @@ const belongsToCreate = (key, state, q, ctx, items) => {
 			};
 			nestedCreateItem.items.push(item);
 			nestedCreateItem.values.push(value[kind]);
-			if (kind !== "connect") for (const key of foreignKeys) item[key] = new RawSql("");
+			if (kind === "create" || kind === "connectOrCreate") for (const key of foreignKeys) item[key] = new RawSql("");
 		}
 	});
 	if (!nestedCreateItems) return;
@@ -853,7 +860,7 @@ const belongsToCreate = (key, state, q, ctx, items) => {
 		(queryForCreate.q.type === "upsert" ? _prependWithOnUpsertCreate : _prependWith)(queryForCreate, asFn, _orCreate(_queryWhere(selectPKeys, [value.where]), value.create));
 	});
 };
-const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
+const nestedUpdate = ({ query, primaryKeys, foreignKeys, len }) => {
 	return ((self, update, params) => {
 		if (params.create) {
 			const createQuery = _querySelect(_queryCreate(query.clone(), params.create), primaryKeys);
@@ -862,7 +869,7 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 		} else if (params.update) {
 			let appendedAs;
 			_hookSelectColumns(self, foreignKeys, (aliasedForeignKeys) => {
-				selectIdsSql._sql = selectCteColumnsSql$1(appendedAs, aliasedForeignKeys);
+				selectIdsSql._sql = selectCteColumnsSql(appendedAs, aliasedForeignKeys);
 			});
 			const selectIdsSql = new RawSql("");
 			const updateQuery = _queryUpdate(_queryWhereIn(query.clone(), true, primaryKeys, selectIdsSql), params.update);
@@ -872,6 +879,7 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 			if (isQueryReturnsAll(self)) throw new Error("`upsert` option is not allowed in a batch update");
 			const { relQuery } = relWithSelectIds(self, query, primaryKeys, foreignKeys);
 			const upsertQuery = _querySelect(_queryUpsert(relQuery, params.upsert), primaryKeys);
+			upsertQuery.q.returnType = "one";
 			const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
 			_prependWith(self, asFn, upsertQuery);
 		} else if (params.delete) {
@@ -897,7 +905,9 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 			}
 			if (loadPrimaryKeys) {
 				const asFn = setForeignKeysFromCte(update, loadPrimaryKeys, loadForeignKeys, true);
-				_prependWith(self, asFn, _queryFindBy(query.select(...loadPrimaryKeys), params.set));
+				const findByQuery = _queryFindBy(query.select(...loadPrimaryKeys), params.set);
+				findByQuery.q.returnType = "value";
+				_prependWith(self, asFn, findByQuery);
 			}
 		}
 	});
@@ -909,7 +919,7 @@ const relWithSelectIds = (self, rel, primaryKeys, foreignKeys) => {
 	const selectIdsQuery = makeSelectIdsQuery(self, foreignKeys);
 	const selectIdsSql = new RawSql("");
 	_prependWith(self, (as) => {
-		selectIdsSql._sql = selectCteColumnsSql$1(as, foreignKeys);
+		selectIdsSql._sql = selectCteColumnsSql(as, foreignKeys);
 	}, selectIdsQuery);
 	return {
 		selectIdsSql,
@@ -929,7 +939,7 @@ var BelongsToVirtualColumn = class extends VirtualColumn {
 		super(schema);
 		this.key = key;
 		this.state = state;
-		this.nestedUpdate = nestedUpdate$2(this.state);
+		this.nestedUpdate = nestedUpdate(this.state);
 	}
 	create(q, ctx, items) {
 		belongsToCreate(this.key, this.state, q, ctx, items);
@@ -1096,7 +1106,7 @@ const hasOneCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes,
 			const connectWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
 			const query = _queryUpdateOrThrow(rel.where(value), connect.items[i]);
 			if (connectWhereExists) _queryWhere(query, [connectWhereExists]);
-			query.q.ensureCount = 1;
+			query.q.ensureCount = { expected: 1 };
 			(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _appendQuery)(querySelf, query, (as) => {
 				upsertCreateAs = as;
 				setUpsertCreatePlaceholders();
@@ -1249,66 +1259,163 @@ const makeHasOneMethod = (tableConfig, table, relation, relationName, query) =>
 		}
 	};
 };
-const getWhereForNestedUpdate = (t, data, params, primaryKeys, foreignKeys) => {
-	return t.where({
-		IN: {
-			columns: foreignKeys,
-			values: data.map((item) => primaryKeys.map((key) => item[key]))
-		},
-		OR: params ? toArray(params) : void 0
-	});
-};
-const nestedUpdate$1 = ({ query: relQuery, primaryKeys, foreignKeys }) => {
-	const len = primaryKeys.length;
-	return (async (_, data, params) => {
-		const t = relQuery.clone();
-		if (params.create) {
-			const obj = {};
-			for (let i = 0; i < len; i++) obj[foreignKeys[i]] = data[0][primaryKeys[i]];
-			await t.insertMany(params.create.map((create) => ({
-				...create,
-				...obj
-			})));
-		}
-		if (params.add) {
-			if (data.length > 1) throw new OrchidOrmInternalError(relQuery, "`connect` is not available when updating multiple records, it is only applicable for a single record update");
-			const obj = {};
-			for (let i = 0; i < len; i++) obj[foreignKeys[i]] = data[0][primaryKeys[i]];
-			const relatedWheres = toArray(params.add);
-			const count = await _queryUpdate(t.where({ OR: relatedWheres }), obj);
-			if (count < relatedWheres.length) throw new OrchidOrmInternalError(relQuery, `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count}`);
-		}
-		if (params.disconnect || params.set) {
-			const obj = {};
-			for (const foreignKey of foreignKeys) obj[foreignKey] = null;
-			const setConditions = params.set && (Array.isArray(params.set) ? params.set.length : objectHasValues(params.set)) && (Array.isArray(params.set) ? { OR: params.set } : params.set);
-			let queryToDisconnect = getWhereForNestedUpdate(t, data, params.disconnect, primaryKeys, foreignKeys);
-			if (setConditions) queryToDisconnect = queryToDisconnect.whereNot(setConditions);
-			await _queryUpdate(queryToDisconnect, obj);
-			if (setConditions) {
-				const obj = {};
-				for (let i = 0; i < len; i++) obj[foreignKeys[i]] = data[0][primaryKeys[i]];
-				await _queryUpdate(t.where(setConditions), obj);
-			}
-		}
-		if (params.delete || params.update) {
-			const q = getWhereForNestedUpdate(t, data, params.delete || params.update?.where, primaryKeys, foreignKeys);
-			if (params.delete) await _queryDelete(q);
-			else if (params.update) await _queryUpdate(q, params.update.data);
-		}
-	});
-};
-const hasManyUpdate = (key, state, nestedUpdateFn, self, set) => {
+const hasManyUpdate = (key, state, self, set) => {
 	const querySelf = self;
 	const params = set[key];
 	throwIfQueryReturnsAllForNestedUpdate(querySelf, params);
-	hasRelationHandleUpdate(querySelf, set, key, state.primaryKeys, nestedUpdateFn);
-	if (params.upsert) {
+	const makeRelationIds = () => makeNestedUpdateRelationIds(querySelf, state.query, state.primaryKeys, state.foreignKeys);
+	const hasDisconnect = !!params.disconnect && (!Array.isArray(params.disconnect) || params.disconnect.length > 0);
+	const hasSetConditions = params.set && (Array.isArray(params.set) ? params.set.length : objectHasValues(params.set));
+	if (hasDisconnect || params.set !== void 0) {
 		const { primaryKeys, foreignKeys, query: relQuery } = state;
-		const ids = makeNestedUpdateRelationIds(querySelf, relQuery, primaryKeys, foreignKeys);
-		const appendedQuery = _queryUpsert(ids.existingRelQuery, makeNestedUpdateUpsertData(params.upsert, ids.setIds));
-		appendedQuery.q.returnType = "void";
-		_appendQuery(querySelf, appendedQuery, ids.setAppendedAs);
+		const relatedAs = relQuery.q.as || relQuery.table;
+		const joinSql = new RawSql("");
+		let mainAs;
+		let aliasedPrimaryKeys;
+		const setNulls = Object.fromEntries(foreignKeys.map((foreignKey) => [foreignKey, null]));
+		let queryToDisconnect = relQuery.clone().updateFrom("");
+		if (hasDisconnect && params.set === void 0) queryToDisconnect = queryToDisconnect.where({ OR: toArray(params.disconnect) });
+		if (params.set && hasSetConditions) queryToDisconnect = queryToDisconnect.whereNot(Array.isArray(params.set) ? { OR: params.set } : params.set);
+		const disconnectQuery = _queryUpdate(queryToDisconnect.whereSql(joinSql), setNulls);
+		disconnectQuery.q.returnType = "void";
+		const setJoinSql = () => {
+			if (mainAs && aliasedPrimaryKeys) joinSql._sql = foreignKeys.map((foreignKey, i) => `"${relatedAs}"."${relQuery.shape[foreignKey].data.name || foreignKey}" = "${mainAs}"."${aliasedPrimaryKeys[i]}"`).join(" AND ");
+		};
+		_hookSelectColumns(querySelf, primaryKeys, (aliased) => {
+			aliasedPrimaryKeys = aliased;
+			setJoinSql();
+		});
+		_appendQuery(querySelf, disconnectQuery, (as) => {
+			mainAs = as;
+			disconnectQuery.q.updateFrom.w = as;
+			disconnectQuery.q.joinedShapes = {
+				...disconnectQuery.q.joinedShapes,
+				[as]: {}
+			};
+			setJoinSql();
+		});
+	}
+	const hasAdd = params.add && (!Array.isArray(params.add) || params.add.length > 0);
+	const updates = params.update ? toArray(params.update) : [];
+	const hasUpdate = updates.some((update) => !Array.isArray(update.where) || update.where.length);
+	const relatedIdsAs = hasUpdate && (hasAdd || hasSetConditions) ? [] : void 0;
+	const sourceCondition = relatedIdsAs ? new RawSql("") : void 0;
+	const updateFrom = relatedIdsAs ? new RawSql("") : void 0;
+	const upsertRelatedIdsAs = params.upsert ? [] : void 0;
+	const upsertSourceCondition = upsertRelatedIdsAs ? new RawSql("") : void 0;
+	const upsertUpdateFrom = upsertRelatedIdsAs ? new RawSql("") : void 0;
+	let appendRelatedQuery;
+	const setSourceCondition = (relatedIdsAs, sourceCondition, updateFrom, relatedPrimaryKeys) => {
+		if (!relatedIdsAs) return;
+		const relatedAs = state.query.q.as || state.query.table;
+		const sourceAs = "\"relatedIds\"";
+		sourceCondition._sql = relatedPrimaryKeys.map((primaryKey) => `"${relatedAs}"."${state.query.shape[primaryKey].data.name || primaryKey}" = ${sourceAs}."${primaryKey}"`).join(" AND ");
+		const columns = relatedPrimaryKeys.map((key) => `"${key}"`).join(", ");
+		updateFrom._sql = `(${relatedIdsAs.map((as) => `SELECT ${columns} FROM ${as._sql}`).join(" UNION ALL ")}) AS ${sourceAs}`;
+	};
+	if (hasAdd || hasSetConditions) {
+		const { query: relQuery } = state;
+		const relatedWheres = [...hasAdd ? toArray(params.add) : [], ...hasSetConditions ? toArray(params.set) : []];
+		if (relatedIdsAs || upsertRelatedIdsAs) {
+			const relatedPrimaryKeys = getPrimaryKeys(relQuery);
+			const relatedQuery = _querySelect(relQuery.clone().where({ OR: relatedWheres }), relatedPrimaryKeys);
+			relatedQuery.q.returnType = "void";
+			_appendQuery(querySelf, relatedQuery, () => {}, (as) => {
+				if (relatedIdsAs) {
+					relatedIdsAs.push(new RawSql(`"${as}"`));
+					setSourceCondition(relatedIdsAs, sourceCondition, updateFrom, relatedPrimaryKeys);
+				}
+				if (upsertRelatedIdsAs) {
+					upsertRelatedIdsAs.push(new RawSql(`"${as}"`));
+					setSourceCondition(upsertRelatedIdsAs, upsertSourceCondition, upsertUpdateFrom, relatedPrimaryKeys);
+				}
+			});
+			if (!querySelf.q.upsertUpdate) relatedQuery.q.ensureCount = {
+				expected: relatedWheres.length,
+				message: `based on \`${hasAdd ? "add" : "set"}\` conditions`
+			};
+		}
+		appendRelatedQuery = () => {
+			const ids = makeRelationIds();
+			const addQuery = _queryUpdate(sourceCondition ? relQuery.clone().where({
+				OR: relatedWheres,
+				NOT: { OR: updates.flatMap((update) => toArray(update.where)) }
+			}) : relQuery.clone().where({ OR: relatedWheres }), ids.setIds);
+			addQuery.q.returnType = "void";
+			if (!sourceCondition && !querySelf.q.upsertUpdate) addQuery.q.ensureCount = {
+				expected: relatedWheres.length,
+				message: `based on \`${hasAdd ? "add" : "set"}\` conditions`
+			};
+			_appendQuery(querySelf, addQuery, ids.setAppendedAs);
+		};
+	}
+	if (upsertRelatedIdsAs) {
+		const { query: relQuery } = state;
+		const ids = makeRelationIds();
+		let existingRelQuery = hasDisconnect ? ids.existingRelQuery.whereNot({ OR: toArray(params.disconnect) }) : ids.existingRelQuery;
+		if (params.set !== void 0) existingRelQuery = hasSetConditions ? existingRelQuery.where(Array.isArray(params.set) ? { OR: params.set } : params.set) : existingRelQuery.none();
+		const relatedPrimaryKeys = getPrimaryKeys(relQuery);
+		const relatedQuery = _querySelect(existingRelQuery, relatedPrimaryKeys);
+		relatedQuery.q.returnType = "void";
+		_appendQuery(querySelf, relatedQuery, ids.setAppendedAs, (as) => {
+			upsertRelatedIdsAs.push(new RawSql(`"${as}"`));
+			setSourceCondition(upsertRelatedIdsAs, upsertSourceCondition, upsertUpdateFrom, relatedPrimaryKeys);
+		});
+	}
+	if (params.delete && (!Array.isArray(params.delete) || params.delete.length > 0)) {
+		const ids = makeRelationIds();
+		const deleteQuery = _queryDelete(ids.existingRelQuery.where({ OR: toArray(params.delete) }));
+		deleteQuery.q.returnType = "void";
+		_appendQuery(querySelf, deleteQuery, ids.setAppendedAs);
+	}
+	appendRelatedQuery?.();
+	if (params.upsert) {
+		const { query: relQuery } = state;
+		for (const upsert of toArray(params.upsert)) {
+			const ids = makeRelationIds();
+			const appendedQuery = _queryUpsert(upsertSourceCondition ? relQuery.clone().where(upsert.findBy).whereSql(upsertSourceCondition) : ids.existingRelQuery.where(upsert.findBy), makeNestedUpdateUpsertData(upsertSourceCondition ? {
+				...upsert,
+				update: {
+					...upsert.update,
+					...ids.setIds
+				}
+			} : upsert, ids.setIds));
+			if (upsertUpdateFrom) appendedQuery.q.updateFrom = {
+				u: true,
+				x: upsertUpdateFrom
+			};
+			appendedQuery.q.returnType = "void";
+			_appendQuery(querySelf, appendedQuery, ids.setAppendedAs);
+		}
+	}
+	if (hasUpdate) for (const update of updates) {
+		if (Array.isArray(update.where) && update.where.length === 0) continue;
+		const { query: relQuery } = state;
+		const ids = makeRelationIds();
+		let relatedUpdateQuery = relQuery.clone().where({ OR: toArray(update.where) });
+		if (sourceCondition) {
+			relatedUpdateQuery.q.updateFrom = {
+				u: true,
+				x: updateFrom
+			};
+			relatedUpdateQuery = relatedUpdateQuery.whereSql(sourceCondition);
+		} else relatedUpdateQuery = ids.existingRelQuery.where({ OR: toArray(update.where) });
+		const updateQuery = _queryUpdate(relatedUpdateQuery, sourceCondition ? {
+			...update.data,
+			...ids.setIds
+		} : update.data);
+		updateQuery.q.returnType = "void";
+		_appendQuery(querySelf, updateQuery, ids.setAppendedAs);
+	}
+	if (params.create?.length) {
+		const { query: relQuery } = state;
+		const ids = makeRelationIds();
+		const createQuery = _queryInsertMany(relQuery.clone(), params.create.map((data) => ({
+			...data,
+			...ids.setIds
+		})));
+		createQuery.q.returnType = "void";
+		_appendQuery(querySelf, createQuery, ids.setAppendedAs);
 	}
 };
 const makeHasManyThroughMethod = ({ table, query, relation, relationName, relPKeys }) => {
@@ -1392,12 +1499,29 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
 			}
 			await _queryCreateMany(t, records);
 		}
+		items.length = 0;
+		for (const item of data) if (item[1].upsert) items.push(item);
+		if (items.length) {
+			const queries = [];
+			for (const [selfData, { upsert }] of items) {
+				const foreignKeyValues = {};
+				for (let i = 0; i < len; i++) foreignKeyValues[foreignKeys[i]] = selfData[primaryKeys[i]];
+				for (const item of toArray(upsert)) queries.push(_queryUpsert(t.clone().where(item.findBy), {
+					update: {
+						...item.update,
+						...foreignKeyValues
+					},
+					create: makeNestedUpdateUpsertData(item, foreignKeyValues).create
+				}));
+			}
+			await Promise.all(queries);
+		}
 	});
 };
 const hasManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes, count) => {
 	const querySelf = self;
 	if (count <= querySelf.qb.internal.nestedCreateBatchMax) {
-		const { query: rel, primaryKeys, foreignKeys } = state;
+		const { query: relQuery, primaryKeys, foreignKeys } = state;
 		let nestedCreateItems;
 		items.forEach((item, i) => {
 			const value = item[key];
@@ -1407,26 +1531,28 @@ const hasManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes,
 					items: []
 				};
 				nestedCreateItem.indexes.push(rowIndexes[i]);
-				const data = value.create.map((obj) => {
-					const data = { ...obj };
-					for (const key of foreignKeys) data[key] = new RawSql("");
-					return data;
-				});
+				const data = value.create.map((obj) => ({
+					...obj,
+					...makeRawSqlPlaceholderRecord(foreignKeys)
+				}));
+				nestedCreateItem.items.push(data);
+			}
+			for (const kind of [
+				"connect",
+				"connectOrCreate",
+				"upsert"
+			]) {
+				const values = kind === "upsert" ? value.upsert ? toArray(value.upsert) : void 0 : value[kind];
+				if (!values?.length) continue;
+				const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
+					indexes: [],
+					items: [],
+					values: []
+				};
+				nestedCreateItem.indexes.push(rowIndexes[i]);
+				nestedCreateItem.values.push(values);
+				const data = makeRawSqlPlaceholderRecord(foreignKeys);
 				nestedCreateItem.items.push(data);
-			} else {
-				const kind = value.connect?.length ? "connect" : value.connectOrCreate?.length ? "connectOrCreate" : void 0;
-				if (kind) {
-					const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
-						indexes: [],
-						items: [],
-						values: []
-					};
-					nestedCreateItem.indexes.push(rowIndexes[i]);
-					nestedCreateItem.values.push(value[kind]);
-					const data = {};
-					for (const key of foreignKeys) data[key] = new RawSql("");
-					nestedCreateItem.items.push(data);
-				}
 			}
 		});
 		if (!nestedCreateItems) return;
@@ -1437,6 +1563,7 @@ const hasManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes,
 		let upsertCreateAs;
 		let connectAs;
 		let connectOrCreateAs;
+		let upsertAs;
 		const setUpsertCreatePlaceholders = () => {
 			if (!upsertCreateAs || !createAliasedPrimaryKeys) return;
 			const aliasedPrimaryKeys = createAliasedPrimaryKeys;
@@ -1444,38 +1571,28 @@ const hasManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes,
 			if (createSelectAs) foreignKeys.forEach((key, keyI) => {
 				createSelectAs[key]._sql = selectCteColumnFromManySql(upsertCreateAs, aliasedPrimaryKeys[keyI], 0, 1);
 			});
-			if (connect) foreignKeys.forEach((key, keyI) => {
-				const primaryKey = aliasedPrimaryKeys[keyI];
-				for (let i = 0; i < connect.items.length; i++) connect.items[i][key]._sql = selectCteColumnFromManySql(upsertCreateAs, primaryKey, connect.indexes[i], count);
-			});
-			if (connectOrCreate) foreignKeys.forEach((key, keyI) => {
-				const primaryKey = aliasedPrimaryKeys[keyI];
-				for (let i = 0; i < connectOrCreate.items.length; i++) connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(upsertCreateAs, primaryKey, connectOrCreate.indexes[i], count);
-			});
+			if (connect) for (let i = 0; i < connect.items.length; i++) setRawSqlPlaceholderRecordFromCte(connect.items[i], foreignKeys, upsertCreateAs, aliasedPrimaryKeys, connect.indexes[i], count);
+			if (connectOrCreate) for (let i = 0; i < connectOrCreate.items.length; i++) setRawSqlPlaceholderRecordFromCte(connectOrCreate.items[i], foreignKeys, upsertCreateAs, aliasedPrimaryKeys, connectOrCreate.indexes[i], count);
+			if (upsert) for (let i = 0; i < upsert.items.length; i++) setRawSqlPlaceholderRecordFromCte(upsert.items[i], foreignKeys, upsertCreateAs, aliasedPrimaryKeys, upsert.indexes[i], count);
 		};
 		_hookSelectColumns(querySelf, primaryKeys, (aliasedPrimaryKeys) => {
 			createAliasedPrimaryKeys = aliasedPrimaryKeys;
-			foreignKeys.forEach((key, keyI) => {
-				const primaryKey = aliasedPrimaryKeys[keyI];
-				if (create && createAs) for (let i = 0; i < create.items.length; i++) {
-					const sql = selectCteColumnFromManySql(createAs, primaryKey, create.indexes[i], count);
-					for (const item of create.items[i]) item[key]._sql = sql;
-				}
-				if (connect && connectAs) for (let i = 0; i < connect.items.length; i++) connect.items[i][key]._sql = selectCteColumnFromManySql(connectAs, primaryKey, connect.indexes[i], count);
-				if (connectOrCreate && connectOrCreateAs) for (let i = 0; i < connectOrCreate.items.length; i++) connectOrCreate.items[i][key]._sql = selectCteColumnFromManySql(connectOrCreateAs, primaryKey, connectOrCreate.indexes[i], count);
-			});
+			if (create && createAs) for (let i = 0; i < create.items.length; i++) for (const item of create.items[i]) setRawSqlPlaceholderRecordFromCte(item, foreignKeys, createAs, aliasedPrimaryKeys, create.indexes[i], count);
+			if (connect && connectAs) for (let i = 0; i < connect.items.length; i++) setRawSqlPlaceholderRecordFromCte(connect.items[i], foreignKeys, connectAs, aliasedPrimaryKeys, connect.indexes[i], count);
+			if (connectOrCreate && connectOrCreateAs) for (let i = 0; i < connectOrCreate.items.length; i++) setRawSqlPlaceholderRecordFromCte(connectOrCreate.items[i], foreignKeys, connectOrCreateAs, aliasedPrimaryKeys, connectOrCreate.indexes[i], count);
+			if (upsert && upsertAs) for (let i = 0; i < upsert.items.length; i++) setRawSqlPlaceholderRecordFromCte(upsert.items[i], foreignKeys, upsertAs, aliasedPrimaryKeys, upsert.indexes[i], count);
 			setUpsertCreatePlaceholders();
 		});
-		const { create, connect, connectOrCreate } = nestedCreateItems;
+		const { create, connect, connectOrCreate, upsert } = nestedCreateItems;
 		if (create) {
 			let query;
 			if (querySelf.q.type === "upsert") {
 				createWhereExists = new RawSql("");
 				createSelectAs = {};
 				for (const key of foreignKeys) createSelectAs[key] = new RawSql("");
-				const sourceQuery = _queryWhere(_queryTake(_querySelect(_clone(rel.qb), [createSelectAs])), [createWhereExists]);
-				query = _queryInsertManyFrom(_clone(rel), sourceQuery, create.items.flat());
-			} else query = _queryInsertMany(_clone(rel), create.items.flat());
+				const sourceQuery = _queryWhere(_queryTake(_querySelect(_clone(relQuery.qb), [createSelectAs])), [createWhereExists]);
+				query = _queryInsertManyFrom(_clone(relQuery), sourceQuery, create.items.flat());
+			} else query = _queryInsertMany(_clone(relQuery), create.items.flat());
 			if (querySelf.q.type === "upsert") _appendQueryOnUpsertCreate(querySelf, query, (as) => {
 				upsertCreateAs = as;
 				setUpsertCreatePlaceholders();
@@ -1484,9 +1601,9 @@ const hasManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes,
 		}
 		if (connect) connect.values.forEach((value, i) => {
 			const connectWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
-			const query = _queryUpdateOrThrow(rel.whereOneOf(...value), connect.items[i]);
+			const query = _queryUpdateOrThrow(relQuery.whereOneOf(...value), connect.items[i]);
 			if (connectWhereExists) _queryWhere(query, [connectWhereExists]);
-			query.q.ensureCount = value.length;
+			query.q.ensureCount = { expected: value.length };
 			(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _appendQuery)(querySelf, query, (as) => {
 				upsertCreateAs = as;
 				setUpsertCreatePlaceholders();
@@ -1501,10 +1618,10 @@ const hasManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes,
 				const connectOrCreateSelectAs = {};
 				if (connectOrCreateWhereExists) for (const key of foreignKeys) {
 					const value = foreignKeyValues[key];
-					value.result = { value: rel.qb.shape[key] };
+					value.result = { value: relQuery.qb.shape[key] };
 					connectOrCreateSelectAs[key] = value;
 				}
-				const query = _queryUpsert(rel.where(value.where), {
+				const query = _queryUpsert(relQuery.where(value.where), {
 					update: foreignKeyValues,
 					create: {
 						...value.create,
@@ -1513,8 +1630,8 @@ const hasManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes,
 				});
 				if (connectOrCreateWhereExists) {
 					_queryWhere(query, [connectOrCreateWhereExists]);
-					const guardQuery = _queryWhere(_queryTake(_querySelect(_clone(rel.qb), [{ one: new RawSql("1") }])), [connectOrCreateWhereExists]);
-					const sourceQuery = _querySelect(_clone(rel.qb).from(guardQuery), [connectOrCreateSelectAs]);
+					const guardQuery = _queryWhere(_queryTake(_querySelect(_clone(relQuery.qb), [{ one: new RawSql("1") }])), [connectOrCreateWhereExists]);
+					const sourceQuery = _querySelect(_clone(relQuery.qb).from(guardQuery), [connectOrCreateSelectAs]);
 					const q = query.q;
 					const columns = q.columns || [];
 					const foreignKeysSet = new Set(foreignKeys);
@@ -1531,6 +1648,43 @@ const hasManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes,
 				});
 			}
 		});
+		if (upsert) upsert.values.forEach((array, i) => {
+			const foreignKeyValues = upsert.items[i];
+			for (const value of array) {
+				const upsertWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
+				const upsertSelectAs = {};
+				if (upsertWhereExists) for (const key of foreignKeys) {
+					const foreignKeyValue = foreignKeyValues[key];
+					foreignKeyValue.result = { value: relQuery.qb.shape[key] };
+					upsertSelectAs[key] = foreignKeyValue;
+				}
+				const query = _queryUpsert(relQuery.where(value.findBy), {
+					update: {
+						...value.update,
+						...foreignKeyValues
+					},
+					create: makeNestedUpdateUpsertData(value, foreignKeyValues).create
+				});
+				if (upsertWhereExists) {
+					_queryWhere(query, [upsertWhereExists]);
+					const guardQuery = _queryWhere(_queryTake(_querySelect(_clone(relQuery.qb), [{ one: new RawSql("1") }])), [upsertWhereExists]);
+					const sourceQuery = _querySelect(_clone(relQuery.qb).from(guardQuery), [upsertSelectAs]);
+					const q = query.q;
+					const columns = q.columns || [];
+					const foreignKeysSet = new Set(foreignKeys);
+					q.columns = [...foreignKeys, ...columns.filter((column) => !foreignKeysSet.has(column))];
+					q.values = q.values.map((row) => row.filter((_, i) => !foreignKeysSet.has(columns[i])));
+					q.queryColumnsCount = foreignKeys.length;
+					q.insertFrom = prepareSubQueryForSql(query, sourceQuery);
+				}
+				(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _appendQuery)(querySelf, query, (as) => {
+					upsertCreateAs = as;
+					setUpsertCreatePlaceholders();
+					upsertAs = as;
+					if (upsertWhereExists) upsertWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+				});
+			}
+		});
 	} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, key, state.primaryKeys, nestedInsertFn);
 };
 var HasManyVirtualColumn = class extends VirtualColumn {
@@ -1539,7 +1693,6 @@ var HasManyVirtualColumn = class extends VirtualColumn {
 		this.key = key;
 		this.state = state;
 		this.nestedInsert = nestedInsert$1(state);
-		this.nestedUpdate = nestedUpdate$1(state);
 		this.setNulls = {};
 		for (const foreignKey of state.foreignKeys) this.setNulls[foreignKey] = null;
 	}
@@ -1547,7 +1700,7 @@ var HasManyVirtualColumn = class extends VirtualColumn {
 		hasManyCreate(this.key, this.state, this.nestedInsert, self, ctx, items, rowIndexes, count);
 	}
 	update(self, set) {
-		hasManyUpdate(this.key, this.state, this.nestedUpdate, self, set);
+		hasManyUpdate(this.key, this.state, self, set);
 	}
 };
 const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
@@ -1606,6 +1759,197 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
 		}
 	};
 };
+const hasAndBelongsToManyCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes, count) => {
+	const querySelf = self;
+	if (count <= querySelf.qb.internal.nestedCreateBatchMax) {
+		const { relatedTableQuery: relQuery, joinTableQuery, primaryKeys, foreignKeys, throughForeignKeys, throughPrimaryKeys } = state;
+		const nestedRecords = [];
+		const nestedConnects = [];
+		const nestedConnectOrCreates = [];
+		const nestedUpserts = [];
+		for (let i = 0; i < items.length; i++) {
+			const value = items[i][key];
+			if (value.create?.length) nestedRecords.push({
+				rowIndex: rowIndexes[i],
+				records: value.create,
+				foreignKeyValues: makeRawSqlPlaceholders(foreignKeys.length)
+			});
+			if (value.connect?.length) nestedConnects.push({
+				rowIndex: rowIndexes[i],
+				connect: value.connect,
+				foreignKeyValues: makeRawSqlPlaceholders(foreignKeys.length)
+			});
+			if (value.connectOrCreate?.length) nestedConnectOrCreates.push({
+				rowIndex: rowIndexes[i],
+				connectOrCreate: value.connectOrCreate,
+				foreignKeyValues: makeRawSqlPlaceholders(foreignKeys.length)
+			});
+			if (value.upsert) nestedUpserts.push({
+				rowIndex: rowIndexes[i],
+				upsert: value.upsert,
+				foreignKeyValues: makeRawSqlPlaceholders(foreignKeys.length)
+			});
+		}
+		if (nestedRecords.length || nestedConnects.length || nestedConnectOrCreates.length || nestedUpserts.length) {
+			let mainAs;
+			let aliasedPrimaryKeysForMain;
+			const setMainForeignKeyValues = () => {
+				if (!mainAs || !aliasedPrimaryKeysForMain) return;
+				for (const { rowIndex, foreignKeyValues } of [
+					...nestedRecords,
+					...nestedConnects,
+					...nestedConnectOrCreates,
+					...nestedUpserts
+				]) setRawSqlPlaceholdersFromCte(foreignKeyValues, mainAs, aliasedPrimaryKeysForMain, rowIndex, count);
+			};
+			const setMainAs = (as) => {
+				mainAs = as;
+				setMainForeignKeyValues();
+			};
+			_hookSelectColumns(querySelf, primaryKeys, (aliasedPrimaryKeys) => {
+				aliasedPrimaryKeysForMain = aliasedPrimaryKeys;
+				setMainForeignKeyValues();
+			});
+			const joinQueries = [];
+			for (const nested of nestedRecords) {
+				const { foreignKeyValues } = nested;
+				const throughForeignKeyValues = makeRawSqlPlaceholders(throughForeignKeys.length);
+				const selectAs = {};
+				for (let i = 0; i < foreignKeys.length; i++) selectAs[foreignKeys[i]] = foreignKeyValues[i];
+				for (let i = 0; i < throughForeignKeys.length; i++) selectAs[throughForeignKeys[i]] = throughForeignKeyValues[i];
+				const joinRows = _querySelect(_clone(relQuery.baseQuery), [selectAs]);
+				const joinQuery = _queryInsertForEachFrom(_clone(joinTableQuery), joinRows);
+				joinQuery.q.returnType = "void";
+				joinQuery.q.ensureCount = { expected: 1 };
+				if (querySelf.q.type === "upsert") {
+					const createWhereExists = new RawSql("");
+					const sourceQuery = _queryWhere(_queryTake(_querySelect(_clone(relQuery.qb), [{}])), [createWhereExists]);
+					const query = _queryInsertManyFrom(_querySelect(_clone(relQuery), throughPrimaryKeys), sourceQuery, nested.records);
+					const queryWithJoin = _appendQuery(query, joinQuery, (as) => {
+						joinRows.q.from = as;
+						joinRows.q.schema = void 0;
+						for (let i = 0; i < throughForeignKeyValues.length; i++) throughForeignKeyValues[i]._sql = `"${as}"."${throughPrimaryKeys[i]}"`;
+					});
+					_appendQueryOnUpsertCreate(querySelf, queryWithJoin, (as) => {
+						setMainAs(as);
+						createWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+					});
+				} else {
+					joinQueries.push(joinQuery);
+					const query = _queryInsertMany(_querySelect(_clone(relQuery), throughPrimaryKeys), nested.records);
+					_appendQuery(querySelf, query, setMainAs, (as) => {
+						joinRows.q.from = as;
+						joinRows.q.schema = void 0;
+						for (let i = 0; i < throughForeignKeyValues.length; i++) throughForeignKeyValues[i]._sql = `"${as}"."${throughPrimaryKeys[i]}"`;
+					});
+				}
+			}
+			for (const { connect, foreignKeyValues } of nestedConnects) for (const item of connect) {
+				const selectAs = {};
+				for (let i = 0; i < foreignKeys.length; i++) selectAs[foreignKeys[i]] = foreignKeyValues[i];
+				for (let i = 0; i < throughForeignKeys.length; i++) selectAs[throughForeignKeys[i]] = throughPrimaryKeys[i];
+				const joinRows = _queryFindBy(_querySelect(_clone(relQuery), [selectAs]), item);
+				const joinQuery = _queryInsertForEachFrom(_clone(joinTableQuery), joinRows);
+				joinQuery.q.returnType = "void";
+				joinQuery.q.ensureCount = { expected: 1 };
+				if (querySelf.q.type === "upsert") {
+					const connectWhereExists = new RawSql("");
+					_queryWhere(joinRows, [connectWhereExists]);
+					_appendQueryOnUpsertCreate(querySelf, joinQuery, (as) => {
+						setMainAs(as);
+						connectWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+					});
+				} else joinQueries.push(joinQuery);
+			}
+			for (const joinQuery of joinQueries) _appendQuery(querySelf, joinQuery, setMainAs);
+			for (const { connectOrCreate, foreignKeyValues } of nestedConnectOrCreates) for (const value of connectOrCreate) {
+				const selectAs = {};
+				for (let i = 0; i < foreignKeys.length; i++) selectAs[foreignKeys[i]] = foreignKeyValues[i];
+				for (let i = 0; i < throughForeignKeys.length; i++) selectAs[throughForeignKeys[i]] = throughPrimaryKeys[i];
+				const connectRows = _queryFindBy(_querySelect(_clone(relQuery), [selectAs]), value.where);
+				const connectQuery = _queryInsertForEachFrom(_clone(joinTableQuery), connectRows);
+				connectQuery.q.returnType = "void";
+				const createWhereNotExists = new RawSql("");
+				const createWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
+				const createSource = _queryWhere(_queryTake(_querySelect(_clone(relQuery.qb), [{}])), [createWhereNotExists, createWhereExists].filter(Boolean));
+				const createQuery = _queryInsertManyFrom(_querySelect(_clone(relQuery), throughPrimaryKeys), createSource, [value.create]);
+				const throughForeignKeyValues = makeRawSqlPlaceholders(throughForeignKeys.length);
+				const createSelectAs = {};
+				for (let i = 0; i < foreignKeys.length; i++) createSelectAs[foreignKeys[i]] = foreignKeyValues[i];
+				for (let i = 0; i < throughForeignKeys.length; i++) createSelectAs[throughForeignKeys[i]] = throughForeignKeyValues[i];
+				const createJoinRows = _querySelect(_clone(relQuery.baseQuery), [createSelectAs]);
+				const createJoinQuery = _queryInsertForEachFrom(_clone(joinTableQuery), createJoinRows);
+				createJoinQuery.q.returnType = "void";
+				if (querySelf.q.type === "upsert") {
+					const connectWhereExists = new RawSql("");
+					_queryWhere(connectRows, [connectWhereExists]);
+					const createQueryWithJoin = _appendQuery(createQuery, createJoinQuery, (as) => {
+						createJoinRows.q.from = as;
+						createJoinRows.q.schema = void 0;
+						for (let i = 0; i < throughForeignKeyValues.length; i++) throughForeignKeyValues[i]._sql = `"${as}"."${throughPrimaryKeys[i]}"`;
+					});
+					const query = _appendQuery(connectQuery, createQueryWithJoin, (as) => {
+						createWhereNotExists._sql = `NOT EXISTS (SELECT 1 FROM "${as}")`;
+					});
+					_appendQueryOnUpsertCreate(querySelf, query, (as) => {
+						setMainAs(as);
+						connectWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+						createWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+					});
+				} else {
+					_appendQuery(querySelf, connectQuery, setMainAs, (as) => {
+						createWhereNotExists._sql = `NOT EXISTS (SELECT 1 FROM "${as}")`;
+					});
+					_appendQuery(querySelf, createQuery, setMainAs, (as) => {
+						createJoinRows.q.from = as;
+						createJoinRows.q.schema = void 0;
+						for (let i = 0; i < throughForeignKeyValues.length; i++) throughForeignKeyValues[i]._sql = `"${as}"."${throughPrimaryKeys[i]}"`;
+					});
+					_appendQuery(querySelf, createJoinQuery, setMainAs);
+				}
+			}
+			for (const { upsert, foreignKeyValues } of nestedUpserts) for (const value of toArray(upsert)) {
+				const upsertWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
+				const makeJoinQuery = () => {
+					const selectAs = {};
+					for (let i = 0; i < foreignKeys.length; i++) selectAs[foreignKeys[i]] = foreignKeyValues[i];
+					for (let i = 0; i < throughForeignKeys.length; i++) selectAs[throughForeignKeys[i]] = new RawSql("");
+					const joinRows = _querySelect(_clone(relQuery.baseQuery), [selectAs]);
+					const joinQuery = _queryInsertForEachFrom(_clone(joinTableQuery), joinRows);
+					joinQuery.q.returnType = "void";
+					return {
+						joinQuery,
+						setJoinRowsFrom: (as) => {
+							joinRows.q.from = as;
+							joinRows.q.schema = void 0;
+							for (let i = 0; i < throughForeignKeys.length; i++) selectAs[throughForeignKeys[i]]._sql = `"${as}"."${throughPrimaryKeys[i]}"`;
+						}
+					};
+				};
+				const updateQuery = _querySelect(_queryUpdate(_clone(relQuery).where(value.findBy), value.update), throughPrimaryKeys);
+				if (upsertWhereExists) _queryWhere(updateQuery, [upsertWhereExists]);
+				const updateJoin = makeJoinQuery();
+				const updateQueryWithJoin = _appendQuery(updateQuery, updateJoin.joinQuery, updateJoin.setJoinRowsFrom);
+				let query = updateQueryWithJoin;
+				if (value.create) {
+					const createWhereNotExists = new RawSql("");
+					const createSource = _queryWhere(_queryTake(_querySelect(_clone(relQuery.qb), [{}])), [createWhereNotExists, upsertWhereExists].filter(Boolean));
+					const create = typeof value.create === "function" ? value.create() : value.create;
+					const createQuery = _queryInsertManyFrom(_querySelect(_clone(relQuery), throughPrimaryKeys), createSource, [create]);
+					const createJoin = makeJoinQuery();
+					const createQueryWithJoin = _appendQuery(createQuery, createJoin.joinQuery, createJoin.setJoinRowsFrom);
+					query = _appendQuery(updateQueryWithJoin, createQueryWithJoin, (as) => {
+						createWhereNotExists._sql = `NOT EXISTS (SELECT 1 FROM "${as}")`;
+					});
+				}
+				(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _appendQuery)(querySelf, query, (as) => {
+					setMainAs(as);
+					if (upsertWhereExists) upsertWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+				});
+			}
+		}
+	} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, key, state.primaryKeys, nestedInsertFn);
+};
 const nestedInsert = ({ relatedTableQuery, joinTableQuery, primaryKeys, foreignKeys, throughPrimaryKeys, throughForeignKeys }) => {
 	const len = primaryKeys.length;
 	const throughLen = primaryKeys.length;
@@ -1650,6 +1994,15 @@ const nestedInsert = ({ relatedTableQuery, joinTableQuery, primaryKeys, foreignK
 			created = await _queryCreateMany(t.select(...throughPrimaryKeys), records);
 		} else created = [];
 		const allKeys = data;
+		for (let index = 0; index < data.length; index++) {
+			const item = data[index][1];
+			if (!item.upsert) continue;
+			const upserted = await Promise.all(toArray(item.upsert).map((upsert) => _querySelect(_queryUpsert(t.clone().where(upsert.findBy), {
+				update: upsert.update,
+				create: upsert.create || {}
+			}), throughPrimaryKeys)));
+			allKeys[index][1] = upserted.map((record) => Array.isArray(record) ? record[0] : record);
+		}
 		let createI = 0;
 		let connectI = 0;
 		connectOrCreateI = 0;
@@ -1691,57 +2044,42 @@ const nestedInsert = ({ relatedTableQuery, joinTableQuery, primaryKeys, foreignK
 		await joinTableQuery.insertMany(records);
 	});
 };
-const selectCteColumnsSql = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
-const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
-const conditionsToWhereArg = (conditions) => Array.isArray(conditions) ? { OR: conditions } : conditions;
-const queryJoinTable = (state, data, conditions) => {
-	const t = state.joinTableQuery.where({ IN: {
-		columns: state.foreignKeys,
-		values: data.map((item) => state.primaryKeys.map((key) => item[key]))
-	} });
-	if (conditions) _queryWhere(t, [{ IN: {
-		columns: state.throughForeignKeys,
-		values: _querySelect(state.relatedTableQuery.where(conditionsToWhereArg(conditions)), state.throughPrimaryKeys)
-	} }]);
-	if (state.on) _queryWhereExists(t, state.relatedTableQuery, [(q) => {
-		for (let i = 0; i < state.throughPrimaryKeys.length; i++) _queryJoinOn(q, [state.throughPrimaryKeysFull[i], state.throughForeignKeysFull[i]]);
-		return q;
-	}]);
-	return t;
-};
-const insertToJoinTable = (state, joinTableTransaction, data, idsRows) => {
-	const len = state.primaryKeys.length;
-	const throughLen = state.throughPrimaryKeys.length;
-	const records = [];
-	for (const item of data) {
-		const obj = {};
-		for (let i = 0; i < len; i++) obj[state.foreignKeys[i]] = item[state.primaryKeys[i]];
-		for (const ids of idsRows) {
-			const record = { ...obj };
-			for (let i = 0; i < throughLen; i++) record[state.throughForeignKeys[i]] = ids[i];
-			records.push(record);
-		}
-	}
-	return joinTableTransaction.insertMany(records);
+const nestedUpdateUpsert = (querySelf, state, upsert, onAppended, updateFrom, sourceCondition, disconnect, set) => {
+	for (const [index, item] of toArray(upsert).entries()) nestedUpdateUpsertOne(querySelf, state, item, (as) => onAppended?.(as, index), updateFrom, sourceCondition, disconnect, set);
 };
-const nestedUpdateUpsert = (querySelf, state, upsert) => {
+const nestedUpdateUpsertOne = (querySelf, state, upsert, onAppended, updateFrom, sourceCondition, disconnect, set) => {
 	const parentIdsSql = new RawSql("");
-	const parentValues = state.foreignKeys.map(() => new RawSql(""));
+	const parentValues = makeRawSqlPlaceholders(state.foreignKeys.length);
 	const relatedIdsSql = new RawSql("");
-	const relatedValues = state.throughPrimaryKeys.map(() => new RawSql(""));
+	const relatedValues = makeRawSqlPlaceholders(state.throughPrimaryKeys.length);
 	let parentAs;
 	_hookSelectColumns(querySelf, state.primaryKeys, (aliasedPrimaryKeys) => {
 		parentIdsSql._sql = selectCteColumnsSql(parentAs, aliasedPrimaryKeys);
 		for (let i = 0; i < state.foreignKeys.length; i++) parentValues[i]._sql = selectCteColumnSql(parentAs, aliasedPrimaryKeys[i]);
 	});
-	const existingRelQuery = _queryWhereExists(_queryWhere(_clone(state.relatedTableQuery), [upsert.findBy]), state.joinTableQuery, [(q) => {
+	let existingRelQuery = _queryWhere(_clone(state.relatedTableQuery), [upsert.findBy]);
+	if (disconnect) existingRelQuery = existingRelQuery.whereNot({ OR: toArray(disconnect) });
+	existingRelQuery = _queryWhereExists(existingRelQuery, state.joinTableQuery, [(q) => {
 		for (let i = 0; i < state.throughPrimaryKeys.length; i++) _queryJoinOn(q, [state.throughForeignKeysFull[i], state.throughPrimaryKeysFull[i]]);
 		return _queryWhereIn(q, true, state.foreignKeysFull, parentIdsSql);
 	}]);
+	if (sourceCondition) {
+		existingRelQuery.q.updateFrom = {
+			u: true,
+			x: updateFrom
+		};
+		const conditions = existingRelQuery.q.and;
+		const existingRelationCondition = conditions.pop();
+		const relationCondition = set ? sourceCondition : { OR: [existingRelationCondition, sourceCondition] };
+		conditions.push(relationCondition);
+	}
 	const upsertQuery = _querySelect(_queryUpsert(existingRelQuery, {
 		update: upsert.update,
 		create: upsert.create || {}
 	}), state.throughPrimaryKeys);
+	upsertQuery.q.returnType = "void";
+	_onUpsertUpdate(upsertQuery, (as) => onAppended?.(as));
+	if (onAppended) upsertQuery.q.upsertCreateAsFns = [...upsertQuery.q.upsertCreateAsFns || [], onAppended];
 	const selectAs = {};
 	for (let i = 0; i < state.foreignKeys.length; i++) selectAs[state.foreignKeys[i]] = parentValues[i];
 	for (let i = 0; i < state.throughForeignKeys.length; i++) selectAs[state.throughForeignKeys[i]] = relatedValues[i];
@@ -1750,72 +2088,197 @@ const nestedUpdateUpsert = (querySelf, state, upsert) => {
 	const joinQuery = state.joinTableQuery.insertForEachFrom(joinRows);
 	joinQuery.q.returnType = "void";
 	_appendQuery(querySelf, _appendQueryOnUpsertCreate(upsertQuery, joinQuery, (as) => {
+		onAppended?.(as);
 		relatedIdsSql._sql = `EXISTS (SELECT 1 FROM "${as}")`;
 		for (let i = 0; i < relatedValues.length; i++) relatedValues[i]._sql = selectCteColumnSql(as, state.throughPrimaryKeys[i]);
 	}), (as) => {
 		parentAs = as;
 	});
 };
-const nestedUpdate = (state) => {
-	const len = state.primaryKeys.length;
-	const throughLen = state.throughPrimaryKeys.length;
-	return (async (query, data, params) => {
-		if (params.create) {
-			const idsRows = await _queryCreateMany(_queryRows(state.relatedTableQuery.select(...state.throughPrimaryKeys)), params.create);
-			const records = [];
-			for (const item of data) {
-				const obj = {};
-				for (let i = 0; i < len; i++) obj[state.foreignKeys[i]] = item[state.primaryKeys[i]];
-				for (const ids of idsRows) {
-					const record = { ...obj };
-					for (let i = 0; i < throughLen; i++) record[state.throughForeignKeys[i]] = ids[i];
-					records.push(record);
-				}
-			}
-			await state.joinTableQuery.createMany(records);
-		}
-		if (params.update) await _queryUpdate(_queryWhere(state.relatedTableQuery.whereExists(state.joinTableQuery, (q) => {
-			for (let i = 0; i < throughLen; i++) _queryJoinOn(q, [state.throughForeignKeysFull[i], state.throughPrimaryKeysFull[i]]);
-			return _queryWhere(q, [{ IN: {
-				columns: state.foreignKeysFull,
-				values: data.map((item) => state.primaryKeys.map((key) => item[key]))
-			} }]);
-		}), [conditionsToWhereArg(params.update.where)]), params.update.data);
-		/**
-		* Performs `insertForEachFrom` on the joining table,
-		* based on a query to the related table with applied filters of `params.connect`,
-		* joins the main table data using `joinData`.
-		*/
-		if (params.add) {
-			const as = query.table;
-			const relatedWheres = toArray(params.add);
-			const joinTableColumns = [...state.foreignKeys, ...state.throughForeignKeys];
-			try {
-				const count = await state.joinTableQuery.insertForEachFrom(_querySelect(state.relatedTableQuery.whereOneOf(...relatedWheres), [Object.fromEntries([...state.primaryKeys.map((key, i) => [state.foreignKeys[i], as + "." + (state.primaryKeysShape[key].data.name || key)]), ...state.throughForeignKeys.map((key, i) => [key, state.throughPrimaryKeys[i]])])]).joinData(as, () => Object.fromEntries(state.primaryKeys.map((key) => [key, state.primaryKeysShape[key]])), data.map((x) => pick(x, state.primaryKeys)))).onConflict(joinTableColumns).merge([state.foreignKeys[0]]);
-				if (count < data.length * relatedWheres.length) throw new OrchidOrmInternalError(query, `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${count / data.length}`);
-			} catch (err) {
-				if (err.code === "42P10") throw new OrchidOrmInternalError(query, `"${state.joinTableQuery.table}" must have a primary key or a unique index on columns (${joinTableColumns.join(", ")}) for this kind of query.`);
-				throw err;
-			}
-		}
-		if (params.disconnect) await _queryDelete(queryJoinTable(state, data, params.disconnect));
-		if (params.delete) {
-			const j = queryJoinTable(state, data, params.delete);
-			const idsRows = await _queryDelete(_queryRows(_querySelect(j, state.throughForeignKeys)));
-			await _queryDelete(state.relatedTableQuery.where({ IN: {
-				columns: state.throughPrimaryKeys,
-				values: idsRows
-			} }));
-		}
-		if (params.set) {
-			const j = queryJoinTable(state, data);
-			await _queryDelete(j);
-			if (Array.isArray(params.set) ? params.set.length : objectHasValues(params.set)) {
-				const idsRows = await _queryRows(_querySelect(state.relatedTableQuery.where(conditionsToWhereArg(params.set)), state.throughPrimaryKeys));
-				await insertToJoinTable(state, j, data, idsRows);
-			}
-		}
+const nestedUpdateAdd = (querySelf, state, add, onAppended) => {
+	const relatedWheres = toArray(add);
+	const joinTableColumns = [...state.foreignKeys, ...state.throughForeignKeys];
+	const parentValues = makeRawSqlPlaceholders(state.foreignKeys.length);
+	const mainQuery = _clone(state.queryBuilder);
+	const isRootUpsert = querySelf.q.upsertUpdate;
+	let parentCount = 0;
+	if (!isRootUpsert) _queryHookAfterUpdate(querySelf, state.primaryKeys, (rows) => {
+		parentCount = rows.length;
+	});
+	_hookSelectColumns(querySelf, state.primaryKeys, (aliased) => {
+		for (let i = 0; i < parentValues.length; i++) parentValues[i]._sql = `"${mainQuery.q.from}"."${aliased[i]}"`;
+	});
+	const joinRows = _querySelect(state.relatedTableQuery.whereOneOf(...relatedWheres), [Object.fromEntries([...state.foreignKeys.map((key, i) => [key, parentValues[i]]), ...state.throughForeignKeys.map((key, i) => [key, state.throughPrimaryKeys[i]])])]).join(mainQuery, true);
+	const joinQuery = state.joinTableQuery.insertForEachFrom(joinRows).onConflict(joinTableColumns).merge([state.foreignKeys[0]]);
+	if (onAppended) _querySelect(joinQuery, state.throughForeignKeys);
+	else joinQuery.q.returnType = "void";
+	if (!isRootUpsert) {
+		joinQuery.q.ensureCount = {
+			expected: relatedWheres.length,
+			message: "based on `add` conditions"
+		};
+		_queryHookAfterCreate(joinQuery, state.foreignKeys, (rows) => {
+			if (rows.length < parentCount * relatedWheres.length) throw new OrchidOrmInternalError(querySelf, `Expected to find at least ${relatedWheres.length} record(s) based on \`add\` conditions, but found ${rows.length / parentCount}`);
+		});
+	}
+	_appendQuery(querySelf, joinQuery, (as) => {
+		mainQuery.q.from = as;
+		mainQuery.q.schema = void 0;
+		mainQuery.q.as = void 0;
+	}, onAppended);
+};
+const nestedUpdateDisconnect = (querySelf, state, disconnect) => {
+	const relatedWheres = toArray(disconnect);
+	const joinTableColumns = [...state.foreignKeys, ...state.throughForeignKeys];
+	const parentValues = makeRawSqlPlaceholders(state.foreignKeys.length);
+	const mainQuery = _clone(state.queryBuilder);
+	_hookSelectColumns(querySelf, state.primaryKeys, (aliased) => {
+		for (let i = 0; i < parentValues.length; i++) parentValues[i]._sql = `"${mainQuery.q.from}"."${aliased[i]}"`;
+	});
+	const joinRows = _querySelect(state.relatedTableQuery.whereOneOf(...relatedWheres), [Object.fromEntries([...state.foreignKeys.map((key, i) => [key, parentValues[i]]), ...state.throughForeignKeys.map((key, i) => [key, state.throughPrimaryKeys[i]])])]).join(mainQuery, true);
+	const joinQuery = _queryDelete(state.joinTableQuery.where({ IN: {
+		columns: joinTableColumns,
+		values: joinRows
+	} }));
+	joinQuery.q.returnType = "void";
+	_appendQuery(querySelf, joinQuery, (as) => {
+		mainQuery.q.from = as;
+		mainQuery.q.schema = void 0;
+		mainQuery.q.as = void 0;
+	});
+};
+const nestedUpdateDelete = (querySelf, state, del) => {
+	const relatedWheres = toArray(del);
+	const parentValues = makeRawSqlPlaceholders(state.foreignKeys.length);
+	const relatedValues = makeRawSqlPlaceholders(state.throughForeignKeys.length);
+	const parentIdsSql = new RawSql("");
+	const mainQuery = _clone(state.queryBuilder);
+	const relatedRows = _querySelect(_clone(state.queryBuilder), [Object.fromEntries([...state.foreignKeys.map((key, i) => [key, parentValues[i]]), ...state.throughForeignKeys.map((key, i) => [key, relatedValues[i]])])]).join(mainQuery, true);
+	_hookSelectColumns(querySelf, state.primaryKeys, (aliased) => {
+		parentIdsSql._sql = selectCteColumnsSql(mainQuery.q.from, aliased);
+		for (let i = 0; i < parentValues.length; i++) parentValues[i]._sql = `"${mainQuery.q.from}"."${aliased[i]}"`;
+	});
+	const relatedQuery = _queryWhereExists(state.relatedTableQuery.whereOneOf(...relatedWheres), state.joinTableQuery, [(q) => {
+		for (let i = 0; i < state.throughPrimaryKeys.length; i++) _queryJoinOn(q, [state.throughForeignKeysFull[i], state.throughPrimaryKeysFull[i]]);
+		return _queryWhereIn(q, true, state.foreignKeysFull, parentIdsSql);
+	}]);
+	const relatedDeleteQuery = _queryDelete(_querySelect(relatedQuery, state.throughPrimaryKeys));
+	relatedDeleteQuery.q.returnType = "void";
+	const joinQuery = _queryDelete(state.joinTableQuery.where({ IN: {
+		columns: [...state.foreignKeys, ...state.throughForeignKeys],
+		values: relatedRows
+	} }));
+	joinQuery.q.returnType = "void";
+	_appendQuery(querySelf, relatedDeleteQuery, () => {}, (as) => {
+		relatedRows.q.from = as;
+		relatedRows.q.schema = void 0;
+		relatedRows.q.as = void 0;
+		for (let i = 0; i < relatedValues.length; i++) relatedValues[i]._sql = `"${as}"."${state.throughPrimaryKeys[i]}"`;
+	});
+	_appendQuery(querySelf, joinQuery, (as) => {
+		mainQuery.q.from = as;
+		mainQuery.q.schema = void 0;
+		mainQuery.q.as = void 0;
+	});
+};
+const nestedUpdateUpdate = (querySelf, state, update, updateFrom, sourceCondition, disconnect, set) => {
+	const parentIdsSql = new RawSql("");
+	const mainQuery = _clone(state.queryBuilder);
+	const isRootUpsert = querySelf.q.upsertUpdate;
+	_hookSelectColumns(querySelf, state.primaryKeys, (aliased) => {
+		parentIdsSql._sql = selectCteColumnsSql(mainQuery.q.from, aliased);
+	});
+	for (const item of toArray(update)) for (const relatedWhere of toArray(item.where)) {
+		let relatedQuery = _queryWhere(_clone(state.relatedTableQuery), [relatedWhere]);
+		if (disconnect) relatedQuery = relatedQuery.whereNot({ OR: toArray(disconnect) });
+		if (sourceCondition) {
+			relatedQuery.q.updateFrom = {
+				u: true,
+				x: updateFrom
+			};
+			relatedQuery = relatedQuery.whereSql(sourceCondition);
+		} else relatedQuery = _queryWhereExists(relatedQuery, state.joinTableQuery, [(q) => {
+			for (let i = 0; i < state.throughPrimaryKeys.length; i++) _queryJoinOn(q, [state.throughForeignKeysFull[i], state.throughPrimaryKeysFull[i]]);
+			return _queryWhereIn(q, true, state.foreignKeysFull, parentIdsSql);
+		}]);
+		const relatedUpdateQuery = _queryUpdate(relatedQuery, item.data);
+		relatedUpdateQuery.q.returnType = "void";
+		if (!isRootUpsert && !disconnect && !set) relatedUpdateQuery.q.ensureCount = { expected: 1 };
+		_appendQuery(querySelf, relatedUpdateQuery, (as) => {
+			mainQuery.q.from = as;
+			mainQuery.q.schema = void 0;
+			mainQuery.q.as = void 0;
+		});
+	}
+};
+const nestedUpdateCreate = (querySelf, state, create) => {
+	const mainQuery = _clone(state.queryBuilder);
+	const parentValues = makeRawSqlPlaceholders(state.foreignKeys.length);
+	const relatedValues = makeRawSqlPlaceholders(state.throughForeignKeys.length);
+	_hookSelectColumns(querySelf, state.primaryKeys, (aliased) => {
+		for (let i = 0; i < parentValues.length; i++) parentValues[i]._sql = `"${mainQuery.q.from}"."${aliased[i]}"`;
+	});
+	const joinRows = _querySelect(_clone(state.relatedTableQuery.baseQuery), [Object.fromEntries([...state.foreignKeys.map((key, i) => [key, parentValues[i]]), ...state.throughForeignKeys.map((key, i) => [key, relatedValues[i]])])]).join(mainQuery, true);
+	const joinQuery = _queryInsertForEachFrom(_clone(state.joinTableQuery), joinRows);
+	joinQuery.q.returnType = "void";
+	const relatedCreateQuery = _queryInsertMany(_querySelect(_clone(state.relatedTableQuery), state.throughPrimaryKeys), create);
+	relatedCreateQuery.q.returnType = "void";
+	_appendQuery(querySelf, relatedCreateQuery, (as) => {
+		mainQuery.q.from = as;
+		mainQuery.q.schema = void 0;
+		mainQuery.q.as = void 0;
+	}, (as) => {
+		joinRows.q.from = as;
+		joinRows.q.schema = void 0;
+		joinRows.q.as = void 0;
+		for (let i = 0; i < relatedValues.length; i++) relatedValues[i]._sql = `"${as}"."${state.throughPrimaryKeys[i]}"`;
+	});
+	_appendQuery(querySelf, joinQuery, () => {});
+};
+const nestedUpdateSet = (querySelf, state, set, onAppended) => {
+	const mainQuery = _clone(state.queryBuilder);
+	const parentIdsSql = new RawSql("");
+	const parentValues = makeRawSqlPlaceholders(state.foreignKeys.length);
+	_hookSelectColumns(querySelf, state.primaryKeys, (aliased) => {
+		parentIdsSql._sql = selectCteColumnsSql(mainQuery.q.from, aliased);
+		for (let i = 0; i < parentValues.length; i++) parentValues[i]._sql = `"${mainQuery.q.from}"."${aliased[i]}"`;
+	});
+	const deleteQuery = _queryDelete(state.joinTableQuery.where({ IN: {
+		columns: state.foreignKeys,
+		values: parentIdsSql
+	} }));
+	deleteQuery.q.returnType = "void";
+	if (state.on) _queryWhereExists(deleteQuery, state.relatedTableQuery, [(q) => {
+		for (let i = 0; i < state.throughPrimaryKeys.length; i++) _queryJoinOn(q, [state.throughPrimaryKeysFull[i], state.throughForeignKeysFull[i]]);
+		return q;
+	}]);
+	_appendQuery(querySelf, deleteQuery, (as) => {
+		mainQuery.q.from = as;
+		mainQuery.q.schema = void 0;
+		mainQuery.q.as = void 0;
 	});
+	if (Array.isArray(set) ? set.length === 0 : !objectHasValues(set)) return;
+	const relatedWheres = toArray(set);
+	const joinTableColumns = [...state.foreignKeys, ...state.throughForeignKeys];
+	const isRootUpsert = querySelf.q.upsertUpdate;
+	let parentCount = 0;
+	if (!isRootUpsert) _queryHookAfterUpdate(querySelf, state.primaryKeys, (rows) => {
+		parentCount = rows.length;
+	});
+	const joinRows = _querySelect(state.relatedTableQuery.whereOneOf(...relatedWheres), [Object.fromEntries([...state.foreignKeys.map((key, i) => [key, parentValues[i]]), ...state.throughForeignKeys.map((key, i) => [key, state.throughPrimaryKeys[i]])])]).join(mainQuery, true);
+	const joinQuery = state.joinTableQuery.insertForEachFrom(joinRows).onConflict(joinTableColumns).merge([state.foreignKeys[0]]);
+	if (onAppended) _querySelect(joinQuery, state.throughForeignKeys);
+	else joinQuery.q.returnType = "void";
+	if (!isRootUpsert) {
+		joinQuery.q.ensureCount = {
+			expected: relatedWheres.length,
+			message: "based on `set` conditions"
+		};
+		_queryHookAfterCreate(joinQuery, state.foreignKeys, (rows) => {
+			if (rows.length < parentCount * relatedWheres.length) throw new OrchidOrmInternalError(querySelf, `Expected to find at least ${relatedWheres.length} record(s) based on \`set\` conditions, but found ${rows.length / parentCount}`);
+		});
+	}
+	_appendQuery(querySelf, joinQuery, () => {}, onAppended);
 };
 var HasAndBelongsToManyVirtualColumn = class extends VirtualColumn {
 	constructor(joinTable, schema, key, state) {
@@ -1824,18 +2287,83 @@ var HasAndBelongsToManyVirtualColumn = class extends VirtualColumn {
 		this.key = key;
 		this.state = state;
 		this.nestedInsert = nestedInsert(state);
-		this.nestedUpdate = nestedUpdate(state);
 	}
-	create(q, ctx, items, rowIndexes) {
-		hasRelationHandleCreate(q, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
+	create(self, ctx, items, rowIndexes, count) {
+		hasAndBelongsToManyCreate(this.key, this.state, this.nestedInsert, self, ctx, items, rowIndexes, count);
 	}
 	update(q, set) {
 		const querySelf = q;
 		const params = set[this.key];
-		hasRelationHandleUpdate(querySelf, set, this.key, this.state.primaryKeys, this.nestedUpdate);
-		if (params.upsert) {
+		const hasUpdate = !!params.update && toArray(params.update).some((update) => !Array.isArray(update.where) || update.where.length);
+		const hasAdd = params.add && (!Array.isArray(params.add) || params.add.length > 0);
+		const addedAs = hasUpdate && hasAdd ? new RawSql("") : void 0;
+		const setAs = hasUpdate && params.set ? new RawSql("") : void 0;
+		const sourceCondition = addedAs || setAs ? new RawSql("") : void 0;
+		const updateFrom = sourceCondition ? new RawSql("") : void 0;
+		const setSourceCondition = () => {
+			if (!sourceCondition) return;
+			const relatedAs = this.state.relatedTableQuery.q.as || this.state.relatedTableQuery.table;
+			const joinCondition = (as) => this.state.throughPrimaryKeys.map((key, i) => `"${relatedAs}"."${this.state.relatedTableQuery.shape[key].data.name || key}" = ${as}."${this.state.throughForeignKeys[i]}"`).join(" AND ");
+			const sourceAs = "\"relatedIds\"";
+			sourceCondition._sql = joinCondition(sourceAs);
+			const sourceColumns = this.state.throughForeignKeys.map((key) => `"${key}"`).join(", ");
+			updateFrom._sql = `(${[addedAs, setAs].filter((as) => !!as && !!as._sql).map((as) => `SELECT ${sourceColumns} FROM ${as._sql}`).concat().join(" UNION ALL ")}) AS ${sourceAs}`;
+		};
+		if (params.add) {
+			nestedUpdateAdd(querySelf, this.state, params.add, (as) => {
+				if (addedAs) {
+					addedAs._sql = `"${as}"`;
+					setSourceCondition();
+				}
+			});
+			set[this.key] = {
+				...params,
+				add: void 0
+			};
+		}
+		if (params.create?.length) {
+			nestedUpdateCreate(querySelf, this.state, params.create);
+			set[this.key] = {
+				...params,
+				create: void 0
+			};
+		}
+		if (params.disconnect && (!Array.isArray(params.disconnect) || params.disconnect.length > 0)) {
+			nestedUpdateDisconnect(querySelf, this.state, params.disconnect);
+			set[this.key] = {
+				...params,
+				disconnect: void 0
+			};
+		}
+		if (params.delete && (!Array.isArray(params.delete) || params.delete.length)) {
+			nestedUpdateDelete(querySelf, this.state, params.delete);
+			set[this.key] = {
+				...params,
+				delete: void 0
+			};
+		}
+		if (params.set) {
+			nestedUpdateSet(querySelf, this.state, params.set, (as) => {
+				if (setAs) {
+					setAs._sql = `"${as}"`;
+					setSourceCondition();
+				}
+			});
+			set[this.key] = {
+				...params,
+				set: void 0
+			};
+		}
+		if (!!params.upsert && (!Array.isArray(params.upsert) || params.upsert.length > 0)) {
 			throwIfQueryReturnsAllForNestedUpdate(querySelf, { upsert: params.upsert });
-			nestedUpdateUpsert(querySelf, this.state, params.upsert);
+			nestedUpdateUpsert(querySelf, this.state, params.upsert, void 0, hasAdd || params.set ? updateFrom : void 0, hasAdd || params.set ? sourceCondition : void 0, params.disconnect, params.set);
+		}
+		if (hasUpdate) {
+			nestedUpdateUpdate(querySelf, this.state, params.update, updateFrom, sourceCondition, params.disconnect, params.set);
+			set[this.key] = {
+				...params,
+				update: void 0
+			};
 		}
 	}
 };