orchid-orm 1.77.0 → 1.77.2

package/dist/index.mjs

@@ -712,6 +712,20 @@ 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 setForeignKeysFromCte = (record, primaryKeys, foreignKeys, mustExist) => {
+	for (const key of foreignKeys) record[key] = new RawSql("");
+	return (as) => {
+		foreignKeys.forEach(mustExist ? (foreignKey, i) => {
+			record[foreignKey]._sql = selectCteColumnMustExistSql(i, as, primaryKeys[i]);
+		} : (foreignKey, i) => {
+			record[foreignKey]._sql = selectCteColumnSql$1(as, primaryKeys[i]);
+		});
+	};
+};
 const joinQueryChainHOF = (relPKeys, reverseJoin, joinQuery) => (joiningQuery, baseQuery) => {
 	const jq = joiningQuery;
 	const chain = jq.q.relChain;
@@ -783,127 +797,68 @@ const wrapQuery = (joiningQuery, result, item) => {
 	result.q.returnsOne = true;
 	return result.wrap(outer);
 };
-var BelongsToVirtualColumn = class extends VirtualColumn {
-	constructor(schema, key, state) {
-		super(schema);
-		this.key = key;
-		this.state = state;
-		this.nestedUpdate = nestedUpdate$2(this.state);
-	}
-	create(q, ctx, items) {
-		const queryForCreate = q;
-		const { key, state: { query, primaryKeys, foreignKeys } } = this;
-		let nestedCreateItems;
-		items.forEach((item) => {
-			const value = item[key];
-			const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
-			if (kind) {
-				const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
-					items: [],
-					values: []
-				};
-				nestedCreateItem.items.push(item);
-				nestedCreateItem.values.push(value[kind]);
-				if (kind !== "connect") for (const key of foreignKeys) item[key] = new RawSql("");
-			}
-		});
-		if (!nestedCreateItems) return;
-		for (const key of foreignKeys) if (!ctx.columns.has(key)) ctx.columns.set(key, ctx.columns.size);
-		const { create, connect, connectOrCreate } = nestedCreateItems;
-		if (create) {
-			const selectPKeys = query.select(...primaryKeys);
-			let createQuery;
-			if (queryForCreate.q.type === "upsert") {
-				const createWhereNotExists = new RawSql("");
-				_onUpsertUpdate(queryForCreate, (as) => {
-					createWhereNotExists._sql = `NOT EXISTS (SELECT 1 FROM "${as}")`;
-				});
-				createQuery = _queryInsertManyFrom(selectPKeys, _queryWhere(_queryTake(_querySelect(_clone(query.qb), [{}])), [createWhereNotExists]), create.values);
-			} else createQuery = _queryInsertMany(selectPKeys, create.values);
-			const setForeignKeys = (as) => {
-				const count = create.items.length;
-				foreignKeys.forEach((foreignKey, i) => {
-					const primaryKey = primaryKeys[i];
-					create.items.forEach((item, i) => {
-						item[foreignKey]._sql = selectCteColumnFromManySql(as, primaryKey, i, count);
-					});
-				});
+const belongsToCreate = (key, state, q, ctx, items) => {
+	const queryForCreate = q;
+	const { query, primaryKeys, foreignKeys } = state;
+	let nestedCreateItems;
+	items.forEach((item) => {
+		const value = item[key];
+		const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
+		if (kind) {
+			const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
+				items: [],
+				values: []
 			};
-			if (queryForCreate.q.type === "upsert") _prependWithOnUpsertCreate(queryForCreate, setForeignKeys, createQuery);
-			else _prependWith(queryForCreate, setForeignKeys, createQuery);
-		}
-		if (connect) connect.values.forEach((value, itemI) => {
-			const as = getFreeAlias(queryForCreate.q.withShapes, "q");
-			(queryForCreate.q.type === "upsert" ? _prependWithOnUpsertCreate : _prependWith)(queryForCreate, as, query.select(...primaryKeys).findBy(value));
-			foreignKeys.map((foreignKey, i) => {
-				connect.items[itemI][foreignKey] = new RawSql(selectCteColumnMustExistSql(i, as, primaryKeys[i]));
+			nestedCreateItem.items.push(item);
+			nestedCreateItem.values.push(value[kind]);
+			if (kind !== "connect") for (const key of foreignKeys) item[key] = new RawSql("");
+		}
+	});
+	if (!nestedCreateItems) return;
+	for (const key of foreignKeys) if (!ctx.columns.has(key)) ctx.columns.set(key, ctx.columns.size);
+	const { create, connect, connectOrCreate } = nestedCreateItems;
+	if (create) {
+		const selectPKeys = query.select(...primaryKeys);
+		let createQuery;
+		if (queryForCreate.q.type === "upsert") {
+			const createWhereNotExists = new RawSql("");
+			_onUpsertUpdate(queryForCreate, (as) => {
+				createWhereNotExists._sql = `NOT EXISTS (SELECT 1 FROM "${as}")`;
 			});
-		});
-		if (connectOrCreate) connectOrCreate.values.forEach((value, itemI) => {
-			const asFn = setForeignKeysFromCte(connectOrCreate.items[itemI], primaryKeys, foreignKeys);
-			const selectPKeys = query.select(...primaryKeys);
-			(queryForCreate.q.type === "upsert" ? _prependWithOnUpsertCreate : _prependWith)(queryForCreate, asFn, _orCreate(_queryWhere(selectPKeys, [value.where]), value.create));
-		});
-	}
-	update(q, set) {
-		const queryForUpdate = q;
-		queryForUpdate.q.wrapInTransaction = true;
-		const data = set[this.key];
-		this.nestedUpdate(queryForUpdate, set, data);
+			const sourceQuery = _queryWhere(_queryTake(_querySelect(_clone(query.qb), [{}])), [createWhereNotExists]);
+			createQuery = _queryInsertManyFrom(selectPKeys, sourceQuery, create.values);
+		} else createQuery = _queryInsertMany(selectPKeys, create.values);
+		const setForeignKeys = (as) => {
+			const count = create.items.length;
+			foreignKeys.forEach((foreignKey, i) => {
+				const primaryKey = primaryKeys[i];
+				create.items.forEach((item, i) => {
+					item[foreignKey]._sql = selectCteColumnFromManySql(as, primaryKey, i, count);
+				});
+			});
+		};
+		if (queryForCreate.q.type === "upsert") _prependWithOnUpsertCreate(queryForCreate, setForeignKeys, createQuery);
+		else _prependWith(queryForCreate, setForeignKeys, createQuery);
 	}
-};
-const getBelongsToRequired = (tableConfig, relatedTableConfig, relation) => {
-	const { required } = relation.options;
-	if (typeof required === "boolean") return required;
-	if (relatedTableConfig.softDelete) return false;
-	return relation.options.columns.every((key) => {
-		return !tableConfig.columns.shape[key].data.isNullable;
+	if (connect) connect.values.forEach((value, itemI) => {
+		const as = getFreeAlias(queryForCreate.q.withShapes, "q");
+		(queryForCreate.q.type === "upsert" ? _prependWithOnUpsertCreate : _prependWith)(queryForCreate, as, query.select(...primaryKeys).findBy(value));
+		foreignKeys.map((foreignKey, i) => {
+			connect.items[itemI][foreignKey] = new RawSql(selectCteColumnMustExistSql(i, as, primaryKeys[i]));
+		});
+	});
+	if (connectOrCreate) connectOrCreate.values.forEach((value, itemI) => {
+		const asFn = setForeignKeysFromCte(connectOrCreate.items[itemI], primaryKeys, foreignKeys);
+		const selectPKeys = query.select(...primaryKeys);
+		(queryForCreate.q.type === "upsert" ? _prependWithOnUpsertCreate : _prependWith)(queryForCreate, asFn, _orCreate(_queryWhere(selectPKeys, [value.where]), value.create));
 	});
-};
-const makeBelongsToMethod = (tableConfig, table, relation, relationName, query) => {
-	const primaryKeys = relation.options.references;
-	const foreignKeys = relation.options.columns;
-	const { on } = relation.options;
-	if (on) {
-		_queryWhere(query, [on]);
-		_queryDefaults(query, on);
-	}
-	const len = primaryKeys.length;
-	const state = {
-		query,
-		primaryKeys,
-		foreignKeys,
-		len,
-		on
-	};
-	addAutoForeignKey(tableConfig, table, query, primaryKeys, foreignKeys, relation.options);
-	const join = (baseQuery, joiningQuery, primaryKeys, foreignKeys) => {
-		const baseAs = getQueryAs(baseQuery);
-		const q = joiningQuery.clone();
-		setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.selectShape);
-		for (let i = 0; i < len; i++) pushQueryOnForOuter(q, baseQuery, joiningQuery, primaryKeys[i], `${baseAs}.${foreignKeys[i]}`);
-		return q;
-	};
-	const reverseJoin = (baseQuery, joiningQuery) => {
-		return join(joiningQuery, baseQuery, foreignKeys, primaryKeys);
-	};
-	return {
-		returns: "one",
-		queryRelated(params) {
-			const obj = {};
-			for (let i = 0; i < len; i++) obj[primaryKeys[i]] = params[foreignKeys[i]];
-			return query.where(obj);
-		},
-		virtualColumn: new BelongsToVirtualColumn(internalSchemaConfig, relationName, state),
-		joinQuery: joinQueryChainHOF(getPrimaryKeys(query), reverseJoin, (joiningQuery, baseQuery) => join(baseQuery, joiningQuery, primaryKeys, foreignKeys)),
-		reverseJoin
-	};
 };
 const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 	return ((self, update, params) => {
 		if (params.create) {
 			const createQuery = _querySelect(_queryCreate(query.clone(), params.create), primaryKeys);
-			_prependWith(self, setForeignKeysFromCte(update, primaryKeys, foreignKeys), createQuery);
+			const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
+			_prependWith(self, asFn, createQuery);
 		} else if (params.update) {
 			let appendedAs;
 			_hookSelectColumns(self, foreignKeys, (aliasedForeignKeys) => {
@@ -917,7 +872,8 @@ 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);
-			_prependWith(self, setForeignKeysFromCte(update, primaryKeys, foreignKeys), upsertQuery);
+			const asFn = setForeignKeysFromCte(update, primaryKeys, foreignKeys);
+			_prependWith(self, asFn, upsertQuery);
 		} else if (params.delete) {
 			_hookSelectColumns(self, foreignKeys, noop);
 			disconnect(update, foreignKeys);
@@ -939,7 +895,10 @@ const nestedUpdate$2 = ({ query, primaryKeys, foreignKeys, len }) => {
 					(loadForeignKeys ??= []).push(foreignKeys[i]);
 				}
 			}
-			if (loadPrimaryKeys) _prependWith(self, setForeignKeysFromCte(update, loadPrimaryKeys, loadForeignKeys, true), _queryFindBy(query.select(...loadPrimaryKeys), params.set));
+			if (loadPrimaryKeys) {
+				const asFn = setForeignKeysFromCte(update, loadPrimaryKeys, loadForeignKeys, true);
+				_prependWith(self, asFn, _queryFindBy(query.select(...loadPrimaryKeys), params.set));
+			}
 		}
 	});
 };
@@ -965,237 +924,68 @@ const makeSelectIdsQuery = (self, foreignKeys) => {
 	selectIdsQuery.q.or = self.q.or;
 	return selectIdsQuery;
 };
-const setForeignKeysFromCte = (record, primaryKeys, foreignKeys, mustExist) => {
-	for (const key of foreignKeys) record[key] = new RawSql("");
-	return (as) => {
-		foreignKeys.forEach(mustExist ? (foreignKey, i) => {
-			record[foreignKey]._sql = selectCteColumnMustExistSql(i, as, primaryKeys[i]);
-		} : (foreignKey, i) => {
-			record[foreignKey]._sql = selectCteColumnSql$1(as, primaryKeys[i]);
-		});
-	};
-};
-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;
-};
-var HasOneVirtualColumn = class extends VirtualColumn {
+var BelongsToVirtualColumn = class extends VirtualColumn {
 	constructor(schema, key, state) {
 		super(schema);
 		this.key = key;
 		this.state = state;
-		this.nestedInsert = nestedInsert$2(state);
-		this.setNulls = {};
-		for (const foreignKey of state.foreignKeys) this.setNulls[foreignKey] = null;
+		this.nestedUpdate = nestedUpdate$2(this.state);
 	}
-	create(self, ctx, items, rowIndexes, count) {
-		const querySelf = self;
-		if (count <= querySelf.qb.internal.nestedCreateBatchMax) {
-			const { query: rel, primaryKeys, foreignKeys } = this.state;
-			let nestedCreateItems;
-			items.forEach((item, i) => {
-				const value = item[this.key];
-				const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
-				if (kind) {
-					const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
-						indexes: [],
-						items: [],
-						values: []
-					};
-					nestedCreateItem.indexes.push(rowIndexes[i]);
-					nestedCreateItem.values.push(value[kind]);
-					const data = value.create ? { ...value.create } : {};
-					for (const key of foreignKeys) data[key] = new RawSql("");
-					nestedCreateItem.items.push(data);
-				}
-			});
-			if (!nestedCreateItems) return;
-			let createAs;
-			let createWhereExists;
-			let createSelectAs;
-			let createAliasedPrimaryKeys;
-			let upsertCreateAs;
-			let connectAs;
-			let connectOrCreateAs;
-			const setUpsertCreatePlaceholders = () => {
-				if (!upsertCreateAs || !createAliasedPrimaryKeys) return;
-				const aliasedPrimaryKeys = createAliasedPrimaryKeys;
-				if (createWhereExists) createWhereExists._sql = `EXISTS (SELECT 1 FROM "${upsertCreateAs}")`;
-				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);
-				});
-			};
-			_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++) create.items[i][key]._sql = selectCteColumnFromManySql(createAs, primaryKey, create.indexes[i], count);
-					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);
-				});
-				setUpsertCreatePlaceholders();
-			});
-			const { create, connect, connectOrCreate } = 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);
-				} else query = _queryInsertMany(_clone(rel), create.items);
-				if (querySelf.q.type === "upsert") _appendQueryOnUpsertCreate(querySelf, query, (as) => {
-					upsertCreateAs = as;
-					setUpsertCreatePlaceholders();
-				});
-				else _appendQuery(querySelf, query, (as) => createAs = as);
-			}
-			if (connect) connect.values.forEach((value, i) => {
-				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;
-				(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _appendQuery)(querySelf, query, (as) => {
-					upsertCreateAs = as;
-					setUpsertCreatePlaceholders();
-					connectAs = as;
-					if (connectWhereExists) connectWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
-				});
-			});
-			if (connectOrCreate) connectOrCreate.values.forEach((value, i) => {
-				const foreignKeyValues = connectOrCreate.items[i];
-				const connectOrCreateWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
-				const connectOrCreateSelectAs = {};
-				if (connectOrCreateWhereExists) for (const key of foreignKeys) {
-					const value = foreignKeyValues[key];
-					value.result = { value: rel.qb.shape[key] };
-					connectOrCreateSelectAs[key] = value;
-				}
-				const query = _queryUpsert(rel.where(value.where), {
-					update: foreignKeyValues,
-					create: {
-						...value.create,
-						...foreignKeyValues
-					}
-				});
-				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 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();
-					connectOrCreateAs = as;
-					if (connectOrCreateWhereExists) connectOrCreateWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
-				});
-			});
-		} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
+	create(q, ctx, items) {
+		belongsToCreate(this.key, this.state, q, ctx, items);
 	}
-	update(self, set) {
-		const querySelf = self;
-		const params = set[this.key];
-		throwIfQueryReturnsAllForNestedUpdate(querySelf, params);
-		const { primaryKeys, foreignKeys, query: relQuery } = this.state;
-		if (params.create || params.update || params.upsert || params.disconnect || params.set || params.delete) {
-			const ids = makeNestedUpdateRelationIds(querySelf, relQuery, primaryKeys, foreignKeys);
-			const nullifyOrDeleteQuery = params.update ? _queryUpdate(ids.existingRelQuery, params.update) : params.upsert ? _queryUpsert(ids.existingRelQuery, makeNestedUpdateUpsertData(params.upsert, ids.setIds)) : params.delete ? _queryDelete(ids.existingRelQuery) : _queryUpdate(ids.existingRelQuery, this.setNulls);
-			nullifyOrDeleteQuery.q.returnType = "void";
-			_appendQuery(querySelf, nullifyOrDeleteQuery, ids.setAppendedAs);
-			if (params.create) _appendQuery(querySelf, _queryInsert(_clone(relQuery), {
-				...params.create,
-				...ids.setIds
-			}), noop);
-			else if (params.set) {
-				const setQuery = _queryUpdate(_queryWhere(_clone(relQuery), [params.set]), ids.setIds);
-				setQuery.q.returnType = "void";
-				_appendQuery(querySelf, setQuery, noop);
-			}
-		}
+	update(q, set) {
+		const queryForUpdate = q;
+		queryForUpdate.q.wrapInTransaction = true;
+		const data = set[this.key];
+		this.nestedUpdate(queryForUpdate, set, data);
 	}
 };
-const makeHasOneMethod = (tableConfig, table, relation, relationName, query) => {
-	const relPKeys = getPrimaryKeys(query);
-	if ("through" in relation.options) {
-		const { through, source, on } = relation.options;
-		if (on) _queryWhere(query, [on]);
-		const throughRelation = getThroughRelation(table, through);
-		const sourceRelation = getSourceRelation(throughRelation, source);
-		const sourceRelationQuery = sourceRelation.query.as(relationName);
-		const sourceQuery = sourceRelation.joinQuery(sourceRelationQuery, throughRelation.query);
-		const whereExistsCallback = () => sourceQuery;
-		const reverseJoin = (baseQuery, joiningQuery) => {
-			return joinHasThrough(baseQuery, baseQuery, joiningQuery, throughRelation, sourceRelation);
-		};
-		return {
-			returns: "one",
-			queryRelated: (params) => {
-				const throughQuery = table.queryRelated(through, params);
-				return query.whereExists(throughQuery, whereExistsCallback);
-			},
-			joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasThrough(joiningQuery, baseQuery, joiningQuery, throughRelation, sourceRelation)),
-			reverseJoin
-		};
-	}
-	const primaryKeys = relation.options.columns;
-	const foreignKeys = relation.options.references;
+const getBelongsToRequired = (tableConfig, relatedTableConfig, relation) => {
+	const { required } = relation.options;
+	if (typeof required === "boolean") return required;
+	if (relatedTableConfig.softDelete) return false;
+	return relation.options.columns.every((key) => {
+		return !tableConfig.columns.shape[key].data.isNullable;
+	});
+};
+const makeBelongsToMethod = (tableConfig, table, relation, relationName, query) => {
+	const primaryKeys = relation.options.references;
+	const foreignKeys = relation.options.columns;
 	const { on } = relation.options;
 	if (on) {
 		_queryWhere(query, [on]);
 		_queryDefaults(query, on);
 	}
-	addAutoForeignKey(tableConfig, query, table, primaryKeys, foreignKeys, relation.options);
+	const len = primaryKeys.length;
 	const state = {
 		query,
 		primaryKeys,
 		foreignKeys,
+		len,
 		on
 	};
-	const len = primaryKeys.length;
-	const reversedOn = {};
-	for (let i = 0; i < len; i++) reversedOn[foreignKeys[i]] = primaryKeys[i];
-	const fromQuerySelect = [{ selectAs: reversedOn }];
+	addAutoForeignKey(tableConfig, table, query, primaryKeys, foreignKeys, relation.options);
+	const join = (baseQuery, joiningQuery, primaryKeys, foreignKeys) => {
+		const baseAs = getQueryAs(baseQuery);
+		const q = joiningQuery.clone();
+		setQueryObjectValueImmutable(q, "joinedShapes", baseAs, baseQuery.q.selectShape);
+		for (let i = 0; i < len; i++) pushQueryOnForOuter(q, baseQuery, joiningQuery, primaryKeys[i], `${baseAs}.${foreignKeys[i]}`);
+		return q;
+	};
 	const reverseJoin = (baseQuery, joiningQuery) => {
-		return joinHasRelation(joiningQuery, baseQuery, foreignKeys, primaryKeys, len);
+		return join(joiningQuery, baseQuery, foreignKeys, primaryKeys);
 	};
 	return {
 		returns: "one",
-		queryRelated: (params) => {
-			const values = {};
-			for (let i = 0; i < len; i++) values[foreignKeys[i]] = params[primaryKeys[i]];
-			return _queryDefaults(query.where(values), {
-				...on,
-				...values
-			});
+		queryRelated(params) {
+			const obj = {};
+			for (let i = 0; i < len; i++) obj[primaryKeys[i]] = params[foreignKeys[i]];
+			return query.where(obj);
 		},
-		virtualColumn: new HasOneVirtualColumn(internalSchemaConfig, relationName, state),
-		joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)),
-		reverseJoin,
-		modifyRelatedQuery(relationQuery) {
-			return (query) => {
-				const baseQuery = query.clone();
-				baseQuery.q.select = fromQuerySelect;
-				const q = relationQuery.q;
-				q.insertFrom = prepareSubQueryForSql(q, baseQuery);
-				q.values = [];
-			};
-		}
+		virtualColumn: new BelongsToVirtualColumn(internalSchemaConfig, relationName, state),
+		joinQuery: joinQueryChainHOF(getPrimaryKeys(query), reverseJoin, (joiningQuery, baseQuery) => join(baseQuery, joiningQuery, primaryKeys, foreignKeys)),
+		reverseJoin
 	};
 };
 const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
@@ -1231,192 +1021,189 @@ const nestedInsert$2 = ({ query, primaryKeys, foreignKeys }) => {
 		}
 	});
 };
-var HasManyVirtualColumn = class extends VirtualColumn {
-	constructor(schema, key, state) {
-		super(schema);
-		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;
-	}
-	create(self, ctx, items, rowIndexes, count) {
-		const querySelf = self;
-		if (count <= querySelf.qb.internal.nestedCreateBatchMax) {
-			const { query: rel, primaryKeys, foreignKeys } = this.state;
-			let nestedCreateItems;
-			items.forEach((item, i) => {
-				const value = item[this.key];
-				if (value.create?.length) {
-					const nestedCreateItem = (nestedCreateItems ??= {}).create ??= {
-						indexes: [],
-						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;
-					});
-					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);
-					}
-				}
+const hasOneCreate = (key, state, nestedInsertFn, self, ctx, items, rowIndexes, count) => {
+	const querySelf = self;
+	if (count <= querySelf.qb.internal.nestedCreateBatchMax) {
+		const { query: rel, primaryKeys, foreignKeys } = state;
+		let nestedCreateItems;
+		items.forEach((item, i) => {
+			const value = item[key];
+			const kind = value.create ? "create" : value.connect ? "connect" : "connectOrCreate";
+			if (kind) {
+				const nestedCreateItem = (nestedCreateItems ??= {})[kind] ??= {
+					indexes: [],
+					items: [],
+					values: []
+				};
+				nestedCreateItem.indexes.push(rowIndexes[i]);
+				nestedCreateItem.values.push(value[kind]);
+				const data = value.create ? { ...value.create } : {};
+				for (const key of foreignKeys) data[key] = new RawSql("");
+				nestedCreateItem.items.push(data);
+			}
+		});
+		if (!nestedCreateItems) return;
+		let createAs;
+		let createWhereExists;
+		let createSelectAs;
+		let createAliasedPrimaryKeys;
+		let upsertCreateAs;
+		let connectAs;
+		let connectOrCreateAs;
+		const setUpsertCreatePlaceholders = () => {
+			if (!upsertCreateAs || !createAliasedPrimaryKeys) return;
+			const aliasedPrimaryKeys = createAliasedPrimaryKeys;
+			if (createWhereExists) createWhereExists._sql = `EXISTS (SELECT 1 FROM "${upsertCreateAs}")`;
+			if (createSelectAs) foreignKeys.forEach((key, keyI) => {
+				createSelectAs[key]._sql = selectCteColumnFromManySql(upsertCreateAs, aliasedPrimaryKeys[keyI], 0, 1);
 			});
-			if (!nestedCreateItems) return;
-			let createAs;
-			let createWhereExists;
-			let createSelectAs;
-			let createAliasedPrimaryKeys;
-			let upsertCreateAs;
-			let connectAs;
-			let connectOrCreateAs;
-			const setUpsertCreatePlaceholders = () => {
-				if (!upsertCreateAs || !createAliasedPrimaryKeys) return;
-				const aliasedPrimaryKeys = createAliasedPrimaryKeys;
-				if (createWhereExists) createWhereExists._sql = `EXISTS (SELECT 1 FROM "${upsertCreateAs}")`;
-				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);
-				});
-			};
-			_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 (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);
+			});
+		};
+		_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++) create.items[i][key]._sql = selectCteColumnFromManySql(createAs, primaryKey, create.indexes[i], count);
+				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);
+			});
+			setUpsertCreatePlaceholders();
+		});
+		const { create, connect, connectOrCreate } = 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);
+			} else query = _queryInsertMany(_clone(rel), create.items);
+			if (querySelf.q.type === "upsert") _appendQueryOnUpsertCreate(querySelf, query, (as) => {
+				upsertCreateAs = as;
 				setUpsertCreatePlaceholders();
 			});
-			const { create, connect, connectOrCreate } = 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());
-				if (querySelf.q.type === "upsert") _appendQueryOnUpsertCreate(querySelf, query, (as) => {
-					upsertCreateAs = as;
-					setUpsertCreatePlaceholders();
-				});
-				else _appendQuery(querySelf, query, (as) => createAs = as);
-			}
-			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]);
-				if (connectWhereExists) _queryWhere(query, [connectWhereExists]);
-				query.q.ensureCount = value.length;
-				(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _appendQuery)(querySelf, query, (as) => {
-					upsertCreateAs = as;
-					setUpsertCreatePlaceholders();
-					connectAs = as;
-					if (connectWhereExists) connectWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
-				});
+			else _appendQuery(querySelf, query, (as) => createAs = as);
+		}
+		if (connect) connect.values.forEach((value, i) => {
+			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;
+			(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _appendQuery)(querySelf, query, (as) => {
+				upsertCreateAs = as;
+				setUpsertCreatePlaceholders();
+				connectAs = as;
+				if (connectWhereExists) connectWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
 			});
-			if (connectOrCreate) connectOrCreate.values.forEach((array, i) => {
-				const foreignKeyValues = connectOrCreate.items[i];
-				for (const value of array) {
-					const connectOrCreateWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
-					const connectOrCreateSelectAs = {};
-					if (connectOrCreateWhereExists) for (const key of foreignKeys) {
-						const value = foreignKeyValues[key];
-						value.result = { value: rel.qb.shape[key] };
-						connectOrCreateSelectAs[key] = value;
-					}
-					const query = _queryUpsert(rel.where(value.where), {
-						update: foreignKeyValues,
-						create: {
-							...value.create,
-							...foreignKeyValues
-						}
-					});
-					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 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();
-						connectOrCreateAs = as;
-						if (connectOrCreateWhereExists) connectOrCreateWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
-					});
+		});
+		if (connectOrCreate) connectOrCreate.values.forEach((value, i) => {
+			const foreignKeyValues = connectOrCreate.items[i];
+			const connectOrCreateWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
+			const connectOrCreateSelectAs = {};
+			if (connectOrCreateWhereExists) for (const key of foreignKeys) {
+				const value = foreignKeyValues[key];
+				value.result = { value: rel.qb.shape[key] };
+				connectOrCreateSelectAs[key] = value;
+			}
+			const query = _queryUpsert(rel.where(value.where), {
+				update: foreignKeyValues,
+				create: {
+					...value.create,
+					...foreignKeyValues
 				}
 			});
-		} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, this.key, this.state.primaryKeys, this.nestedInsert);
+			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 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();
+				connectOrCreateAs = as;
+				if (connectOrCreateWhereExists) connectOrCreateWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+			});
+		});
+	} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, key, state.primaryKeys, nestedInsertFn);
+};
+const hasOneThrough = (table, options, relationName, query, relPKeys) => {
+	const { through, source, on } = options;
+	if (on) _queryWhere(query, [on]);
+	const throughRelation = getThroughRelation(table, through);
+	const sourceRelation = getSourceRelation(throughRelation, source);
+	const sourceRelationQuery = sourceRelation.query.as(relationName);
+	const sourceQuery = sourceRelation.joinQuery(sourceRelationQuery, throughRelation.query);
+	const whereExistsCallback = () => sourceQuery;
+	const reverseJoin = (baseQuery, joiningQuery) => {
+		return joinHasThrough(baseQuery, baseQuery, joiningQuery, throughRelation, sourceRelation);
+	};
+	return {
+		returns: "one",
+		queryRelated: (params) => {
+			const throughQuery = table.queryRelated(through, params);
+			return query.whereExists(throughQuery, whereExistsCallback);
+		},
+		joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasThrough(joiningQuery, baseQuery, joiningQuery, throughRelation, sourceRelation)),
+		reverseJoin
+	};
+};
+const hasOneUpdate = (key, state, self, set) => {
+	const querySelf = self;
+	const params = set[key];
+	throwIfQueryReturnsAllForNestedUpdate(querySelf, params);
+	const { primaryKeys, foreignKeys, query: relQuery } = state;
+	if (params.create || params.update || params.upsert || params.disconnect || params.set || params.delete) {
+		const ids = makeNestedUpdateRelationIds(querySelf, relQuery, primaryKeys, foreignKeys);
+		const setNulls = {};
+		for (const foreignKey of foreignKeys) setNulls[foreignKey] = null;
+		const nullifyOrDeleteQuery = params.update ? _queryUpdate(ids.existingRelQuery, params.update) : params.upsert ? _queryUpsert(ids.existingRelQuery, makeNestedUpdateUpsertData(params.upsert, ids.setIds)) : params.delete ? _queryDelete(ids.existingRelQuery) : _queryUpdate(ids.existingRelQuery, setNulls);
+		nullifyOrDeleteQuery.q.returnType = "void";
+		_appendQuery(querySelf, nullifyOrDeleteQuery, ids.setAppendedAs);
+		if (params.create) {
+			const createQuery = _queryInsert(_clone(relQuery), {
+				...params.create,
+				...ids.setIds
+			});
+			_appendQuery(querySelf, createQuery, noop);
+		} else if (params.set) {
+			const setQuery = _queryUpdate(_queryWhere(_clone(relQuery), [params.set]), ids.setIds);
+			setQuery.q.returnType = "void";
+			_appendQuery(querySelf, setQuery, noop);
+		}
+	}
+};
+var HasOneVirtualColumn = class extends VirtualColumn {
+	constructor(schema, key, state) {
+		super(schema);
+		this.key = key;
+		this.state = state;
+		this.nestedInsert = nestedInsert$2(state);
+	}
+	create(self, ctx, items, rowIndexes, count) {
+		hasOneCreate(this.key, this.state, this.nestedInsert, self, ctx, items, rowIndexes, count);
 	}
 	update(self, set) {
-		const querySelf = self;
-		const params = set[this.key];
-		throwIfQueryReturnsAllForNestedUpdate(querySelf, params);
-		hasRelationHandleUpdate(querySelf, set, this.key, this.state.primaryKeys, this.nestedUpdate);
-		if (params.upsert) {
-			const { primaryKeys, foreignKeys, query: relQuery } = this.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);
-		}
+		hasOneUpdate(this.key, this.state, self, set);
 	}
 };
-const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
+const makeHasOneMethod = (tableConfig, table, relation, relationName, query) => {
 	const relPKeys = getPrimaryKeys(query);
-	if ("through" in relation.options) {
-		const { through, source, on } = relation.options;
-		if (on) _queryWhere(query, [on]);
-		const throughRelation = getThroughRelation(table, through);
-		const sourceRelation = getSourceRelation(throughRelation, source);
-		const sourceRelationQuery = sourceRelation.query.as(relationName);
-		const sourceQuery = sourceRelation.joinQuery(sourceRelationQuery, throughRelation.query);
-		const whereExistsCallback = () => sourceQuery;
-		const reverseJoin = (baseQuery, joiningQuery) => {
-			return joinHasThrough(baseQuery, baseQuery, joiningQuery, throughRelation, sourceRelation);
-		};
-		return {
-			returns: "many",
-			queryRelated: (params) => {
-				const throughQuery = table.queryRelated(through, params);
-				return query.whereExists(throughQuery, whereExistsCallback);
-			},
-			joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasThrough(joiningQuery, baseQuery, joiningQuery, throughRelation, sourceRelation)),
-			reverseJoin
-		};
-	}
+	if ("through" in relation.options) return hasOneThrough(table, relation.options, relationName, query, relPKeys);
 	const primaryKeys = relation.options.columns;
 	const foreignKeys = relation.options.references;
 	const { on } = relation.options;
@@ -1439,7 +1226,7 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
 		return joinHasRelation(joiningQuery, baseQuery, foreignKeys, primaryKeys, len);
 	};
 	return {
-		returns: "many",
+		returns: "one",
 		queryRelated: (params) => {
 			const values = {};
 			for (let i = 0; i < len; i++) values[foreignKeys[i]] = params[primaryKeys[i]];
@@ -1448,7 +1235,7 @@ const makeHasManyMethod = (tableConfig, table, relation, relationName, query) =>
 				...values
 			});
 		},
-		virtualColumn: new HasManyVirtualColumn(internalSchemaConfig, relationName, state),
+		virtualColumn: new HasOneVirtualColumn(internalSchemaConfig, relationName, state),
 		joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)),
 		reverseJoin,
 		modifyRelatedQuery(relationQuery) {
@@ -1471,6 +1258,81 @@ const getWhereForNestedUpdate = (t, data, params, primaryKeys, foreignKeys) => {
 		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 querySelf = self;
+	const params = set[key];
+	throwIfQueryReturnsAllForNestedUpdate(querySelf, params);
+	hasRelationHandleUpdate(querySelf, set, key, state.primaryKeys, nestedUpdateFn);
+	if (params.upsert) {
+		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 makeHasManyThroughMethod = ({ table, query, relation, relationName, relPKeys }) => {
+	if (!("through" in relation.options)) return;
+	const { through, source, on } = relation.options;
+	if (on) _queryWhere(query, [on]);
+	const throughRelation = getThroughRelation(table, through);
+	const sourceRelation = getSourceRelation(throughRelation, source);
+	const sourceRelationQuery = sourceRelation.query.as(relationName);
+	const sourceQuery = sourceRelation.joinQuery(sourceRelationQuery, throughRelation.query);
+	const whereExistsCallback = () => sourceQuery;
+	const reverseJoin = (baseQuery, joiningQuery) => {
+		return joinHasThrough(baseQuery, baseQuery, joiningQuery, throughRelation, sourceRelation);
+	};
+	return {
+		returns: "many",
+		queryRelated: (params) => {
+			const throughQuery = table.queryRelated(through, params);
+			return query.whereExists(throughQuery, whereExistsCallback);
+		},
+		joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasThrough(joiningQuery, baseQuery, joiningQuery, throughRelation, sourceRelation)),
+		reverseJoin
+	};
+};
 const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
 	const len = primaryKeys.length;
 	return (async (_, data) => {
@@ -1532,257 +1394,218 @@ const nestedInsert$1 = ({ query, primaryKeys, foreignKeys }) => {
 		}
 	});
 };
-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);
+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;
+		let nestedCreateItems;
+		items.forEach((item, i) => {
+			const value = item[key];
+			if (value.create?.length) {
+				const nestedCreateItem = (nestedCreateItems ??= {}).create ??= {
+					indexes: [],
+					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;
+				});
+				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 (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);
-		}
-	});
-};
-var HasAndBelongsToManyVirtualColumn = class extends VirtualColumn {
-	constructor(joinTable, schema, key, state) {
-		super(schema);
-		this.joinTable = joinTable;
-		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);
-	}
-	update(q, set) {
-		const querySelf = q;
-		const params = set[this.key];
-		hasRelationHandleUpdate(querySelf, set, this.key, this.state.primaryKeys, this.nestedUpdate);
-		if (params.upsert) {
-			throwIfQueryReturnsAllForNestedUpdate(querySelf, { upsert: params.upsert });
-			nestedUpdateUpsert(querySelf, this.state, params.upsert);
-		}
-	}
-};
-const selectCteColumnsSql = (cteAs, columns) => `(SELECT ${columns.map((c) => `"${cteAs}"."${c}"`).join(", ")} FROM "${cteAs}")`;
-const selectCteColumnSql = (cteAs, column) => `(SELECT "${cteAs}"."${column}" FROM "${cteAs}")`;
-const nestedUpdateUpsert = (querySelf, state, upsert) => {
-	const parentIdsSql = new RawSql("");
-	const parentValues = state.foreignKeys.map(() => new RawSql(""));
-	const relatedIdsSql = new RawSql("");
-	const relatedValues = state.throughPrimaryKeys.map(() => new RawSql(""));
-	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 upsertQuery = _querySelect(_queryUpsert(_queryWhereExists(_queryWhere(_clone(state.relatedTableQuery), [upsert.findBy]), 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);
-	}]), {
-		update: upsert.update,
-		create: upsert.create || {}
-	}), state.throughPrimaryKeys);
-	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];
-	const joinRows = _querySelect(_clone(state.queryBuilder), [selectAs]);
-	_queryWhere(joinRows, [relatedIdsSql]);
-	const joinQuery = state.joinTableQuery.insertForEachFrom(joinRows);
-	joinQuery.q.returnType = "void";
-	_appendQuery(querySelf, _appendQueryOnUpsertCreate(upsertQuery, joinQuery, (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;
-	});
+		});
+		if (!nestedCreateItems) return;
+		let createAs;
+		let createWhereExists;
+		let createSelectAs;
+		let createAliasedPrimaryKeys;
+		let upsertCreateAs;
+		let connectAs;
+		let connectOrCreateAs;
+		const setUpsertCreatePlaceholders = () => {
+			if (!upsertCreateAs || !createAliasedPrimaryKeys) return;
+			const aliasedPrimaryKeys = createAliasedPrimaryKeys;
+			if (createWhereExists) createWhereExists._sql = `EXISTS (SELECT 1 FROM "${upsertCreateAs}")`;
+			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);
+			});
+		};
+		_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);
+			});
+			setUpsertCreatePlaceholders();
+		});
+		const { create, connect, connectOrCreate } = 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());
+			if (querySelf.q.type === "upsert") _appendQueryOnUpsertCreate(querySelf, query, (as) => {
+				upsertCreateAs = as;
+				setUpsertCreatePlaceholders();
+			});
+			else _appendQuery(querySelf, query, (as) => createAs = as);
+		}
+		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]);
+			if (connectWhereExists) _queryWhere(query, [connectWhereExists]);
+			query.q.ensureCount = value.length;
+			(querySelf.q.type === "upsert" ? _appendQueryOnUpsertCreate : _appendQuery)(querySelf, query, (as) => {
+				upsertCreateAs = as;
+				setUpsertCreatePlaceholders();
+				connectAs = as;
+				if (connectWhereExists) connectWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+			});
+		});
+		if (connectOrCreate) connectOrCreate.values.forEach((array, i) => {
+			const foreignKeyValues = connectOrCreate.items[i];
+			for (const value of array) {
+				const connectOrCreateWhereExists = querySelf.q.type === "upsert" ? new RawSql("") : void 0;
+				const connectOrCreateSelectAs = {};
+				if (connectOrCreateWhereExists) for (const key of foreignKeys) {
+					const value = foreignKeyValues[key];
+					value.result = { value: rel.qb.shape[key] };
+					connectOrCreateSelectAs[key] = value;
+				}
+				const query = _queryUpsert(rel.where(value.where), {
+					update: foreignKeyValues,
+					create: {
+						...value.create,
+						...foreignKeyValues
+					}
+				});
+				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 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();
+					connectOrCreateAs = as;
+					if (connectOrCreateWhereExists) connectOrCreateWhereExists._sql = `EXISTS (SELECT 1 FROM "${as}")`;
+				});
+			}
+		});
+	} else hasRelationHandleCreate(querySelf, ctx, items, rowIndexes, key, state.primaryKeys, nestedInsertFn);
 };
-const removeColumnName = (column) => {
-	if (!column.data.name) return column;
-	const cloned = Object.create(column);
-	cloned.data = {
-		...column.data,
-		name: void 0
-	};
-	return cloned;
+var HasManyVirtualColumn = class extends VirtualColumn {
+	constructor(schema, key, state) {
+		super(schema);
+		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;
+	}
+	create(self, ctx, items, rowIndexes, count) {
+		hasManyCreate(this.key, this.state, this.nestedInsert, self, ctx, items, rowIndexes, count);
+	}
+	update(self, set) {
+		hasManyUpdate(this.key, this.state, this.nestedUpdate, self, set);
+	}
 };
-const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relationName, query, schema) => {
-	const { options } = relation;
-	const { snakeCase } = table.internal;
-	const primaryKeys = options.columns;
-	const originalForeignKeys = options.references;
-	const foreignKeys = snakeCase ? [...originalForeignKeys] : originalForeignKeys;
-	const joinTable = snakeCase && options.through.snakeCase !== false ? toSnakeCase(options.through.table) : options.through.table;
-	const originalThroughForeignKeys = options.through.columns;
-	const throughForeignKeys = snakeCase ? [...originalThroughForeignKeys] : originalThroughForeignKeys;
-	const throughPrimaryKeys = options.through.references;
-	const { on } = options;
+const makeHasManyMethod = (tableConfig, table, relation, relationName, query) => {
+	const relPKeys = getPrimaryKeys(query);
+	const throughResult = makeHasManyThroughMethod({
+		table,
+		query,
+		relation,
+		relationName,
+		relPKeys
+	});
+	if (throughResult) return throughResult;
+	const opts = relation.options;
+	const primaryKeys = opts.columns;
+	const foreignKeys = opts.references;
+	const { on } = opts;
 	if (on) {
 		_queryWhere(query, [on]);
 		_queryDefaults(query, on);
 	}
-	const foreignKeysFull = foreignKeys.map((key, i) => {
-		if (snakeCase) key = foreignKeys[i] = toSnakeCase(key);
-		return `${joinTable}.${key}`;
-	});
-	const throughForeignKeysFull = throughForeignKeys.map((key, i) => {
-		if (snakeCase) key = throughForeignKeys[i] = toSnakeCase(key);
-		return `${joinTable}.${key}`;
-	});
-	const foreignTable = getQueryAs(query);
-	const throughPrimaryKeysFull = throughPrimaryKeys.map((key) => `${foreignTable}.${key}`);
-	const len = primaryKeys.length;
-	const throughLen = throughPrimaryKeys.length;
-	const baseQuery = Object.create(qb.baseQuery);
-	baseQuery.baseQuery = baseQuery;
-	baseQuery.table = joinTable;
-	const shape = {};
-	const primaryKeysShape = {};
-	for (let i = 0; i < len; i++) {
-		const pk = primaryKeys[i];
-		shape[foreignKeys[i]] = removeColumnName(table.shape[pk]);
-		primaryKeysShape[pk] = table.shape[pk];
-	}
-	for (let i = 0; i < throughLen; i++) shape[throughForeignKeys[i]] = removeColumnName(query.shape[throughPrimaryKeys[i]]);
-	baseQuery.shape = shape;
-	baseQuery.q = {
-		...baseQuery.q,
-		schema: options.through.schema || schema,
-		shape: baseQuery.shape
-	};
-	const subQuery = Object.create(baseQuery);
-	addAutoForeignKey(tableConfig, subQuery, table, primaryKeys, foreignKeys, relation.options, originalForeignKeys);
-	addAutoForeignKey(tableConfig, subQuery, query, throughPrimaryKeys, throughForeignKeys, relation.options.through, originalThroughForeignKeys);
+	addAutoForeignKey(tableConfig, query, table, primaryKeys, foreignKeys, opts);
 	const state = {
-		queryBuilder: qb,
-		relatedTableQuery: query,
-		joinTableQuery: subQuery,
+		query,
 		primaryKeys,
 		foreignKeys,
-		throughForeignKeys,
-		throughPrimaryKeys,
-		foreignKeysFull,
-		throughForeignKeysFull,
-		throughPrimaryKeysFull,
-		primaryKeysShape,
 		on
 	};
-	const joinQuery = (joiningQuery, tableAs, foreignAs, joinedShapes) => {
-		const cloned = joiningQuery.clone();
-		cloned.q.joinedShapes = joinedShapes;
-		return _queryWhereExists(cloned, subQuery, [(q) => {
-			for (let i = 0; i < throughLen; i++) _queryJoinOn(q, [throughForeignKeysFull[i], `${foreignAs}.${throughPrimaryKeys[i]}`]);
-			for (let i = 0; i < len; i++) _queryJoinOn(q, [foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`]);
-			return q;
-		}]);
-	};
-	const obj = {};
-	for (let i = 0; i < len; i++) obj[foreignKeys[i]] = primaryKeys[i];
-	const selectPrimaryKeysAsForeignKeys = [{ selectAs: obj }];
+	const len = primaryKeys.length;
+	const reversedOn = {};
+	for (let i = 0; i < len; i++) reversedOn[foreignKeys[i]] = primaryKeys[i];
+	const fromQuerySelect = [{ selectAs: reversedOn }];
 	const reverseJoin = (baseQuery, joiningQuery) => {
-		const foreignAs = getQueryAs(joiningQuery);
-		return joinQuery(baseQuery, getQueryAs(baseQuery), foreignAs, {
-			...baseQuery.q.joinedShapes,
-			[foreignAs]: joiningQuery.q.selectShape
-		});
+		return joinHasRelation(joiningQuery, baseQuery, foreignKeys, primaryKeys, len);
 	};
 	return {
 		returns: "many",
-		queryRelated(params) {
-			const q = query.whereExists(subQuery, (q) => {
-				q = q.clone();
-				const where = {};
-				for (let i = 0; i < len; i++) where[foreignKeysFull[i]] = params[primaryKeys[i]];
-				for (let i = 0; i < throughLen; i++) _queryJoinOn(q, [throughForeignKeysFull[i], throughPrimaryKeysFull[i]]);
-				return _queryWhere(q, [where]);
+		queryRelated: (params) => {
+			const values = {};
+			for (let i = 0; i < len; i++) values[foreignKeys[i]] = params[primaryKeys[i]];
+			return _queryDefaults(query.where(values), {
+				...on,
+				...values
 			});
-			return on ? _queryDefaults(q, on) : q;
 		},
-		virtualColumn: new HasAndBelongsToManyVirtualColumn(subQuery, internalSchemaConfig, relationName, state),
-		joinQuery: joinQueryChainHOF(getPrimaryKeys(query), reverseJoin, (joiningQuery, baseQuery) => joinQuery(joiningQuery, getQueryAs(baseQuery), getQueryAs(joiningQuery), {
-			...joiningQuery.q.joinedShapes,
-			[baseQuery.q.as || baseQuery.table]: baseQuery.q.selectShape
-		})),
+		virtualColumn: new HasManyVirtualColumn(internalSchemaConfig, relationName, state),
+		joinQuery: joinQueryChainHOF(relPKeys, reverseJoin, (joiningQuery, baseQuery) => joinHasRelation(baseQuery, joiningQuery, primaryKeys, foreignKeys, len)),
 		reverseJoin,
 		modifyRelatedQuery(relationQuery) {
-			const ref = {};
-			_queryHookAfterCreate(relationQuery, [], async (result) => {
-				const baseQuery = ref.q.clone();
-				baseQuery.q.select = selectPrimaryKeysAsForeignKeys;
-				const data = result.map((resultRow) => {
-					const dataRow = {};
-					for (let i = 0; i < throughLen; i++) dataRow[throughForeignKeys[i]] = resultRow[throughPrimaryKeys[i]];
-					return dataRow;
-				});
-				if (await _queryCreateManyFrom(subQuery.count(), baseQuery, data) === 0) throw new NotFoundError(baseQuery);
-			});
-			return (q) => {
-				ref.q = q;
+			return (query) => {
+				const baseQuery = query.clone();
+				baseQuery.q.select = fromQuerySelect;
+				const q = relationQuery.q;
+				q.insertFrom = prepareSubQueryForSql(q, baseQuery);
+				q.values = [];
 			};
 		}
 	};
 };
-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 conditionsToWhereArg = (conditions) => Array.isArray(conditions) ? { OR: conditions } : conditions;
-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 nestedInsert = ({ relatedTableQuery, joinTableQuery, primaryKeys, foreignKeys, throughPrimaryKeys, throughForeignKeys }) => {
 	const len = primaryKeys.length;
 	const throughLen = primaryKeys.length;
@@ -1868,6 +1691,71 @@ 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) => {
+	const parentIdsSql = new RawSql("");
+	const parentValues = state.foreignKeys.map(() => new RawSql(""));
+	const relatedIdsSql = new RawSql("");
+	const relatedValues = state.throughPrimaryKeys.map(() => new RawSql(""));
+	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) => {
+		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 upsertQuery = _querySelect(_queryUpsert(existingRelQuery, {
+		update: upsert.update,
+		create: upsert.create || {}
+	}), state.throughPrimaryKeys);
+	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];
+	const joinRows = _querySelect(_clone(state.queryBuilder), [selectAs]);
+	_queryWhere(joinRows, [relatedIdsSql]);
+	const joinQuery = state.joinTableQuery.insertForEachFrom(joinRows);
+	joinQuery.q.returnType = "void";
+	_appendQuery(querySelf, _appendQueryOnUpsertCreate(upsertQuery, joinQuery, (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;
@@ -1912,7 +1800,8 @@ const nestedUpdate = (state) => {
 		}
 		if (params.disconnect) await _queryDelete(queryJoinTable(state, data, params.disconnect));
 		if (params.delete) {
-			const idsRows = await _queryDelete(_queryRows(_querySelect(queryJoinTable(state, data, params.delete), state.throughForeignKeys)));
+			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
@@ -1921,10 +1810,160 @@ const nestedUpdate = (state) => {
 		if (params.set) {
 			const j = queryJoinTable(state, data);
 			await _queryDelete(j);
-			if (Array.isArray(params.set) ? params.set.length : objectHasValues(params.set)) await insertToJoinTable(state, j, data, await _queryRows(_querySelect(state.relatedTableQuery.where(conditionsToWhereArg(params.set)), state.throughPrimaryKeys)));
+			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);
+			}
 		}
 	});
 };
+var HasAndBelongsToManyVirtualColumn = class extends VirtualColumn {
+	constructor(joinTable, schema, key, state) {
+		super(schema);
+		this.joinTable = joinTable;
+		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);
+	}
+	update(q, set) {
+		const querySelf = q;
+		const params = set[this.key];
+		hasRelationHandleUpdate(querySelf, set, this.key, this.state.primaryKeys, this.nestedUpdate);
+		if (params.upsert) {
+			throwIfQueryReturnsAllForNestedUpdate(querySelf, { upsert: params.upsert });
+			nestedUpdateUpsert(querySelf, this.state, params.upsert);
+		}
+	}
+};
+const removeColumnName = (column) => {
+	if (!column.data.name) return column;
+	const cloned = Object.create(column);
+	cloned.data = {
+		...column.data,
+		name: void 0
+	};
+	return cloned;
+};
+const makeHasAndBelongsToManyMethod = (tableConfig, table, qb, relation, relationName, query, schema) => {
+	const { options } = relation;
+	const { snakeCase } = table.internal;
+	const primaryKeys = options.columns;
+	const originalForeignKeys = options.references;
+	const foreignKeys = snakeCase ? [...originalForeignKeys] : originalForeignKeys;
+	const joinTable = snakeCase && options.through.snakeCase !== false ? toSnakeCase(options.through.table) : options.through.table;
+	const originalThroughForeignKeys = options.through.columns;
+	const throughForeignKeys = snakeCase ? [...originalThroughForeignKeys] : originalThroughForeignKeys;
+	const throughPrimaryKeys = options.through.references;
+	const { on } = options;
+	if (on) {
+		_queryWhere(query, [on]);
+		_queryDefaults(query, on);
+	}
+	const foreignKeysFull = foreignKeys.map((key, i) => {
+		if (snakeCase) key = foreignKeys[i] = toSnakeCase(key);
+		return `${joinTable}.${key}`;
+	});
+	const throughForeignKeysFull = throughForeignKeys.map((key, i) => {
+		if (snakeCase) key = throughForeignKeys[i] = toSnakeCase(key);
+		return `${joinTable}.${key}`;
+	});
+	const foreignTable = getQueryAs(query);
+	const throughPrimaryKeysFull = throughPrimaryKeys.map((key) => `${foreignTable}.${key}`);
+	const len = primaryKeys.length;
+	const throughLen = throughPrimaryKeys.length;
+	const baseQuery = Object.create(qb.baseQuery);
+	baseQuery.baseQuery = baseQuery;
+	baseQuery.table = joinTable;
+	const shape = {};
+	const primaryKeysShape = {};
+	for (let i = 0; i < len; i++) {
+		const pk = primaryKeys[i];
+		shape[foreignKeys[i]] = removeColumnName(table.shape[pk]);
+		primaryKeysShape[pk] = table.shape[pk];
+	}
+	for (let i = 0; i < throughLen; i++) shape[throughForeignKeys[i]] = removeColumnName(query.shape[throughPrimaryKeys[i]]);
+	baseQuery.shape = shape;
+	baseQuery.q = {
+		...baseQuery.q,
+		schema: options.through.schema || schema,
+		shape: baseQuery.shape
+	};
+	const subQuery = Object.create(baseQuery);
+	addAutoForeignKey(tableConfig, subQuery, table, primaryKeys, foreignKeys, relation.options, originalForeignKeys);
+	addAutoForeignKey(tableConfig, subQuery, query, throughPrimaryKeys, throughForeignKeys, relation.options.through, originalThroughForeignKeys);
+	const state = {
+		queryBuilder: qb,
+		relatedTableQuery: query,
+		joinTableQuery: subQuery,
+		primaryKeys,
+		foreignKeys,
+		throughForeignKeys,
+		throughPrimaryKeys,
+		foreignKeysFull,
+		throughForeignKeysFull,
+		throughPrimaryKeysFull,
+		primaryKeysShape,
+		on
+	};
+	const joinQuery = (joiningQuery, tableAs, foreignAs, joinedShapes) => {
+		const cloned = joiningQuery.clone();
+		cloned.q.joinedShapes = joinedShapes;
+		return _queryWhereExists(cloned, subQuery, [(q) => {
+			for (let i = 0; i < throughLen; i++) _queryJoinOn(q, [throughForeignKeysFull[i], `${foreignAs}.${throughPrimaryKeys[i]}`]);
+			for (let i = 0; i < len; i++) _queryJoinOn(q, [foreignKeysFull[i], `${tableAs}.${primaryKeys[i]}`]);
+			return q;
+		}]);
+	};
+	const obj = {};
+	for (let i = 0; i < len; i++) obj[foreignKeys[i]] = primaryKeys[i];
+	const selectPrimaryKeysAsForeignKeys = [{ selectAs: obj }];
+	const reverseJoin = (baseQuery, joiningQuery) => {
+		const foreignAs = getQueryAs(joiningQuery);
+		return joinQuery(baseQuery, getQueryAs(baseQuery), foreignAs, {
+			...baseQuery.q.joinedShapes,
+			[foreignAs]: joiningQuery.q.selectShape
+		});
+	};
+	return {
+		returns: "many",
+		queryRelated(params) {
+			const q = query.whereExists(subQuery, (q) => {
+				q = q.clone();
+				const where = {};
+				for (let i = 0; i < len; i++) where[foreignKeysFull[i]] = params[primaryKeys[i]];
+				for (let i = 0; i < throughLen; i++) _queryJoinOn(q, [throughForeignKeysFull[i], throughPrimaryKeysFull[i]]);
+				return _queryWhere(q, [where]);
+			});
+			return on ? _queryDefaults(q, on) : q;
+		},
+		virtualColumn: new HasAndBelongsToManyVirtualColumn(subQuery, internalSchemaConfig, relationName, state),
+		joinQuery: joinQueryChainHOF(getPrimaryKeys(query), reverseJoin, (joiningQuery, baseQuery) => joinQuery(joiningQuery, getQueryAs(baseQuery), getQueryAs(joiningQuery), {
+			...joiningQuery.q.joinedShapes,
+			[baseQuery.q.as || baseQuery.table]: baseQuery.q.selectShape
+		})),
+		reverseJoin,
+		modifyRelatedQuery(relationQuery) {
+			const ref = {};
+			_queryHookAfterCreate(relationQuery, [], async (result) => {
+				const baseQuery = ref.q.clone();
+				baseQuery.q.select = selectPrimaryKeysAsForeignKeys;
+				const data = result.map((resultRow) => {
+					const dataRow = {};
+					for (let i = 0; i < throughLen; i++) dataRow[throughForeignKeys[i]] = resultRow[throughPrimaryKeys[i]];
+					return dataRow;
+				});
+				if (await _queryCreateManyFrom(subQuery.count(), baseQuery, data) === 0) throw new NotFoundError(baseQuery);
+			});
+			return (q) => {
+				ref.q = q;
+			};
+		}
+	};
+};
 const applyRelations = (qb, tables, result, schema) => {
 	const tableEntries = Object.entries(tables);
 	const delayedRelations = /* @__PURE__ */ new Map();