pqb 0.71.4 → 0.72.0

package/dist/index.js

@@ -455,9 +455,14 @@ var RawSql = class extends Expression {
 };
 const isRawSQL = (arg) => arg instanceof RawSql;
 RawSql.prototype.type = ExpressionTypeMethod.prototype.type;
-const rawSqlToCode = (rawSql, t) => {
+const rawSqlToCode = (rawSql, ctx) => {
 	const { _sql: sql, _values: values } = rawSql;
-	let code = `${t}.sql`;
+	let code;
+	if (typeof ctx === "string") code = `${ctx}.sql`;
+	else {
+		ctx.isSqlUsed = true;
+		code = ctx.sql ?? `${ctx.t}.sql`;
+	}
 	code += typeof sql === "string" ? values ? `({ raw: '${sql.replace(/'/g, "\\'")}' })` : `\`${sql.replace(/`/g, "\\`")}\`` : templateLiteralSQLToCode(sql);
 	if (values) code += `.values(${JSON.stringify(values)})`;
 	return code;
@@ -593,6 +598,15 @@ const parseIndexOrExclude = (item) => {
 	for (let i = item.columns.length - 1; i >= 0; i--) if (typeof item.columns[i] === "string") item.columns[i] = { column: item.columns[i] };
 	return item;
 };
+const getForeignKeyTableInstance = (table) => {
+	const item = "instance" in table ? table.instance() : new table();
+	if (!item.table) throw new Error("Referenced table is missing table property");
+	return {
+		...item,
+		schema: typeof item.schema === "function" ? item.schema() : item.schema,
+		table: item.table
+	};
+};
 function makeColumnNullable(column, inputSchema, outputSchema, querySchema) {
 	const c = setColumnData(column, "isNullable", true);
 	c.inputSchema = inputSchema;
@@ -664,20 +678,17 @@ var Column = class {
 	* Or you can specify a callback that returns a value. This function will be called for each creating record. Such a default won't be applied to a database.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     // values as defaults:
-	*     int: t.integer().default(123),
-	*     text: t.text().default('text'),
+	* export const Table = defineTable('table', (t) => ({
+	*   // values as defaults:
+	*   int: t.integer().default(123),
+	*   text: t.text().default('text'),
 	*
-	*     // raw SQL default:
-	*     timestamp: t.timestamp().default(t.sql`now()`),
+	*   // raw SQL default:
+	*   timestamp: t.timestamp().default(t.sql`now()`),
 	*
-	*     // runtime default, each new records gets a new random value:
-	*     random: t.numeric().default(() => Math.random()),
-	*   }));
-	* }
+	*   // runtime default, each new records gets a new random value:
+	*   random: t.numeric().default(() => Math.random()),
+	* }));
 	* ```
 	*
 	* @param value - default value or a function returning a value
@@ -772,14 +783,11 @@ var Column = class {
 	* It won't be selected with `selectAll` or `select('*')` as well.
 	*
 	* ```ts
-	* export class UserTable extends BaseTable {
-	*   readonly table = 'user';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     name: t.string(),
-	*     password: t.string().select(false),
-	*   }));
-	* }
+	* export const UserTable = defineTable('user', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   name: t.string(),
+	*   password: t.string().select(false),
+	* }));
 	*
 	* // only id and name are selected, without password
 	* const user = await db.user.find(123);
@@ -822,20 +830,17 @@ var Column = class {
 	* `readOnly` column can be used together with a `default`.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     column: t.string().default(() => 'default value'),
-	*     another: t.string().readOnly(),
-	*   }));
-	*
-	*   init(orm: typeof db) {
-	*     this.beforeSave(({ set }) => {
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   column: t.string().default(() => 'default value'),
+	*   another: t.string().nullable().readOnly(),
+	* })).init((orm: typeof db, hooks) => {
+	*   hooks.beforeSave(({ columns, set }) => {
+	*     if (columns.include('column')) {
 	*       set({ another: 'value' });
-	*     });
-	*   }
-	* }
+	*     }
+	*   });
+	* });
 	*
 	* // later in the code
 	* db.table.create({ column: 'value' }); // TS error, runtime error
@@ -851,13 +856,15 @@ var Column = class {
 	* If no value or undefined is returned, the hook won't have any effect.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     column: t.string().setOnCreate(() => 'value'),
-	*   }));
-	* }
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   some: t.number(),
+	*   column: t
+	*     .string()
+	*     .setOnCreate(({ columns }) =>
+	*       columns.include('some') ? 'value' : undefined,
+	*     ),
+	* }));
 	* ```
 	*/
 	setOnCreate(fn) {
@@ -870,13 +877,15 @@ var Column = class {
 	* If no value or undefined is returned, the hook won't have any effect.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     column: t.string().setOnUpdate(() => 'value'),
-	*   }));
-	* }
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   some: t.number(),
+	*   column: t
+	*     .string()
+	*     .setOnUpdate(({ columns }) =>
+	*       columns.include('some') ? 'value' : undefined,
+	*     ),
+	* }));
 	* ```
 	*/
 	setOnUpdate(fn) {
@@ -889,13 +898,15 @@ var Column = class {
 	* If no value or undefined is returned, the hook won't have any effect.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     column: t.string().setOnSave(() => 'value'),
-	*   }));
-	* }
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   some: t.number(),
+	*   column: t
+	*     .string()
+	*     .setOnSave(({ columns }) =>
+	*       columns.include('some') ? 'value' : undefined,
+	*     ),
+	* }));
 	* ```
 	*/
 	setOnSave(fn) {
@@ -910,14 +921,11 @@ var Column = class {
 	* Using `primaryKey` on a `uuid` column will automatically add a [gen_random_uuid](https://www.postgresql.org/docs/current/functions-uuid.html) default.
 	*
 	* ```ts
-	* export class Table extends BaseTable {
-	*   readonly table = 'table';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.uuid().primaryKey(),
-	*     // database-level name can be passed:
-	*     id: t.uuid().primaryKey('primary_key_name'),
-	*   }));
-	* }
+	* export const Table = defineTable('table', (t) => ({
+	*   id: t.uuid().primaryKey(),
+	*   // optionally, specify a database-level constraint name:
+	*   id: t.uuid().primaryKey('primary_key_name'),
+	* }));
 	*
 	* // primary key can be used by `find` later:
 	* db.table.find('97ba9e78-7510-415a-9c03-23d440aec443');
@@ -1307,8 +1315,8 @@ const codeToString = (code, tabs, shift) => {
 * @param t - column types variable name
 * @param value - column default
 */
-const columnDefaultArgumentToCode = (t, value) => {
-	if (typeof value === "object" && value && isRawSQL(value)) return rawSqlToCode(value, t);
+const columnDefaultArgumentToCode = (ctx, value) => {
+	if (typeof value === "object" && value && isRawSQL(value)) return rawSqlToCode(value, ctx);
 	else if (typeof value === "function") return value.toString();
 	else if (typeof value === "string") return singleQuote(value);
 	else return JSON.stringify(value);
@@ -1552,26 +1560,26 @@ const excludeInnerToCode = (item, t) => {
 	return code;
 };
 const excludeToCode = indexOrExcludeToCode(excludeInnerToCode);
-const constraintToCode = (item, t, m, prefix) => {
-	const code = constraintInnerToCode(item, t, m);
+const constraintToCode = (item, t, m, prefix, ctx) => {
+	const code = constraintInnerToCode(item, t, m, ctx);
 	if (prefix) code[0] = prefix + code[0];
 	const last = code[code.length - 1];
 	if (typeof last === "string" && !last.endsWith(",")) code[code.length - 1] += ",";
 	return code;
 };
-const constraintInnerToCode = (item, t, m) => {
+const constraintInnerToCode = (item, t, m, ctx) => {
 	if (item.references) return [
 		`${t}.foreignKey(`,
 		referencesArgsToCode(item.references, item.name, m),
 		"),"
 	];
-	return [`${t}.check(${rawSqlToCode(item.check, t)}${item.name ? `, ${singleQuote(item.name)}` : ""})`];
+	return [`${t}.check(${rawSqlToCode(item.check, ctx ?? t)}${item.name ? `, ${singleQuote(item.name)}` : ""})`];
 };
 const referencesArgsToCode = ({ columns, fnOrTable, foreignColumns, options }, name = options?.name || false, m) => {
 	const args = [];
 	args.push(`${singleQuoteArray(columns)},`);
 	if (m && typeof fnOrTable !== "string") {
-		const { schema, table } = new (fnOrTable())();
+		const { schema, table } = getForeignKeyTableInstance(fnOrTable());
 		fnOrTable = schema ? `${schema}.${table}` : table;
 	}
 	args.push(`${typeof fnOrTable === "string" ? singleQuote(fnOrTable) : fnOrTable.toString()},`);
@@ -1600,7 +1608,7 @@ const columnForeignKeysToCode = (foreignKeys, migration) => {
 const foreignKeyArgumentToCode = ({ fnOrTable, foreignColumns, options = emptyObject }, migration) => {
 	const code = [];
 	if (migration && typeof fnOrTable !== "string") {
-		const { schema, table } = new (fnOrTable())();
+		const { schema, table } = getForeignKeyTableInstance(fnOrTable());
 		fnOrTable = schema ? `${schema}.${table}` : table;
 	}
 	code.push(typeof fnOrTable === "string" ? singleQuote(fnOrTable) : fnOrTable.toString());
@@ -1668,7 +1676,7 @@ const columnExcludesToCode = (items) => {
 	return code;
 };
 const columnCheckToCode = (ctx, checks) => {
-	return checks.map(({ sql, name }) => `.check(${rawSqlToCode(sql, ctx.t)}${name ? `, '${name}'` : ""})`).join("");
+	return checks.map(({ sql, name }) => `.check(${rawSqlToCode(sql, ctx)}${name ? `, '${name}'` : ""})`).join("");
 };
 const identityToCode = (identity, dataType) => {
 	const code = [];
@@ -1704,7 +1712,7 @@ const columnCode = (type, ctx, key, code) => {
 	if (data.explicitSelect) addCode(code, ".select(false)");
 	if (data.isNullable) addCode(code, ".nullable()");
 	if (data.as && !ctx.migration) addCode(code, `.as(${data.as.toCode(ctx, key)})`);
-	if (data.default !== void 0 && data.default !== data.defaultDefault && (!ctx.migration || typeof data.default !== "function")) addCode(code, `.default(${columnDefaultArgumentToCode(ctx.t, data.default)})`);
+	if (data.default !== void 0 && data.default !== data.defaultDefault && (!ctx.migration || typeof data.default !== "function")) addCode(code, `.default(${columnDefaultArgumentToCode(ctx, data.default)})`);
 	if (data.indexes) for (const part of columnIndexesToCode(data.indexes)) addCode(code, part);
 	if (data.excludes) for (const part of columnExcludesToCode(data.excludes)) addCode(code, part);
 	if (data.comment) addCode(code, `.comment(${singleQuote(data.comment)})`);
@@ -3742,24 +3750,19 @@ var QueryStorage = class {
 * so later they can be identified when handling after commit errors.
 *
 * ```ts
-* class SomeTable extends BaseTable {
-*   readonly table = 'someTable';
-*   columns = this.setColumns((t) => ({
-*     ...someColumns,
-*   }));
-*
-*   init(orm: typeof db) {
-*     // anonymous funciton - has no name
-*     this.afterCreateCommit([], async () => {
-*       // ...
-*     });
+* export const SomeTable = defineTable('someTable', (t) => ({
+*   ...someColumns,
+* })).init((orm: typeof db, hooks) => {
+*   // anonymous funciton - has no name
+*   hooks.afterCreateCommit([], async () => {
+*     // ...
+*   });
 *
-*     // named function
-*     this.afterCreateCommit([], function myHook() => {
-*       // ...
-*     });
-*   }
-* }
+*   // named function
+*   hooks.afterCreateCommit([], function myHook() {
+*     // ...
+*   });
+* });
 * ```
 */
 var AfterCommitError = class extends OrchidOrmError {
@@ -4512,21 +4515,16 @@ const _unscope = (q, scope) => {
 * If you define a scope with name `default`, it will be applied for all table queries by default.
 *
 * ```ts
-* import { BaseTable } from './baseTable';
+* import { defineTable } from './table-factory';
 *
-* export class SomeTable extends BaseTable {
-*   readonly table = 'some';
-*   columns = this.setColumns((t) => ({
-*     id: t.identity().primaryKey(),
-*     hidden: t.boolean(),
-*     active: t.boolean(),
-*   }));
-*
-*   scopes = this.setScopes({
-*     default: (q) => q.where({ hidden: false }),
-*     active: (q) => q.where({ active: true }),
-*   });
-* }
+* export const SomeTable = defineTable('some', (t) => ({
+*   id: t.identity().primaryKey(),
+*   hidden: t.boolean(),
+*   active: t.boolean(),
+* })).scopes({
+*   default: (q) => q.where({ hidden: false }),
+*   active: (q) => q.where({ active: true }),
+* });
 *
 * const db = orchidORM(
 *   { databaseURL: '...' },
@@ -5834,7 +5832,7 @@ var Where = class {
 	* Constructing `WHERE` conditions:
 	*
 	* ```ts
-	* import { sql } from './baseTable'
+	* import { sql } from './table-factory';
 	*
 	* db.table.where({
 	*   // column of the current table
@@ -5850,7 +5848,7 @@ var Where = class {
 	*   },
 	*
 	*   // where column equals to raw SQL
-	*   // import `sql` from your `BaseTable`
+	*   // import `sql` from your table factory
 	*   column: sql`sql expression`,
 	*   // or use `(q) => sql` for the same
 	*   column2: (q) => sql`sql expression`,
@@ -9173,31 +9171,26 @@ var QueryCreate = class {
 	* A primary key or a unique index for a **single** column can be fined on a column:
 	*
 	* ```ts
-	* export class MyTable extends BaseTable {
-	*   columns = this.setColumns((t) => ({
-	*     pkey: t.uuid().primaryKey(),
-	*     unique: t.string().unique(),
-	*   }));
-	* }
+	* export const MyTable = defineTable('myTable', (t) => ({
+	*   pkey: t.uuid().primaryKey(),
+	*   unique: t.string().unique(),
+	* }));
 	* ```
 	*
 	* But for composite primary keys or indexes (having multiple columns), define it in a separate function:
 	*
 	* ```ts
-	* export class MyTable extends BaseTable {
-	*   columns = this.setColumns(
-	*     (t) => ({
-	*       one: t.integer(),
-	*       two: t.string(),
-	*       three: t.boolean(),
-	*     }),
-	*     (t) => [t.primaryKey(['one', 'two']), t.unique(['two', 'three'])],
-	*   );
-	* }
+	* export const MyTable = defineTable('myTable', (t) => ({
+	*   one: t.integer(),
+	*   two: t.string(),
+	*   three: t.boolean(),
+	* }))
+	*   .primaryKey(['one', 'two'])
+	*   .unique(['two', 'three']);
 	* ```
 	* :::
 	*
-	* You can use the `sql` function exported from your `BaseTable` file in onConflict.
+	* You can use the `sql` function exported from your table factory file in onConflict.
 	* It can be useful to specify a condition when you have a partial index:
 	*
 	* ```ts
@@ -9587,12 +9580,14 @@ const toSql = (table, type, topCtx, isSubSql, cteName, calledByThen, dontAddTabl
 				if (upsertOrCreate.q.returnType === "oneOrThrow") upsertOrCreate.q.returnType = "one";
 				else if (upsertOrCreate.q.returnType === "valueOrThrow") upsertOrCreate.q.returnType = "value";
 				const { as, makeSql: makeFirstSql } = moveMutativeQueryToCteBase(toSql, ctx, upsertOrCreate, upsertUpdate ? "update" : null);
+				query.upsertUpdateAsFns?.forEach((fn) => fn(as));
 				upsertOrCreate.q.or = upsertOrCreate.q.scopes = void 0;
 				upsertOrCreate.q.and = [new RawSql(`NOT EXISTS (SELECT 1 FROM "${as}")`)];
 				if (query.upsertInsert) {
 					_queryInsert(upsertOrCreate, query.upsertInsert());
 					upsertOrCreate.q.type = "upsert";
 				}
+				upsertOrCreate.q.with = query.upsertCreateWith;
 				upsertOrCreate.q.appendQueries = query.upsertCreateAppendQueries;
 				upsertOrCreate.q.asFns = query.upsertCreateAsFns;
 				const { makeSql: makeSecondSql } = moveMutativeQueryToCteBase(toSql, ctx, upsertOrCreate, "insert");
@@ -10164,36 +10159,21 @@ var QueryJoin = class {
 	* For the following examples, imagine you have a `User` table with `id` and `name`, and `Message` table with `id`, `text`, messages belongs to user via `userId` column:
 	*
 	* ```ts
-	* export class UserTable extends BaseTable {
-	*   readonly table = 'user';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     name: t.text(),
-	*   }));
-	*
-	*   relations = {
-	*     messages: this.hasMany(() => MessageTable, {
-	*       primaryKey: 'id',
-	*       foreignKey: 'userId',
-	*     }),
-	*   };
-	* }
-	*
-	* export class MessageTable extends BaseTable {
-	*   readonly table = 'message';
-	*   columns = this.setColumns((t) => ({
-	*     id: t.identity().primaryKey(),
-	*     text: t.text(),
-	*     ...t.timestamps(),
-	*   }));
+	* export const UserTable = defineTable('user', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   name: t.text(),
+	* })).relations((user) => ({
+	*   messages: user('id').hasMany(() => MessageTable('userId')),
+	* }));
 	*
-	*   relations = {
-	*     user: this.belongsTo(() => UserTable, {
-	*       primaryKey: 'id',
-	*       foreignKey: 'userId',
-	*     }),
-	*   };
-	* }
+	* export const MessageTable = defineTable('message', (t) => ({
+	*   id: t.identity().primaryKey(),
+	*   userId: t.integer(),
+	*   text: t.text(),
+	*   ...t.timestamps(),
+	* })).relations((message) => ({
+	*   user: message('userId').belongsTo(() => UserTable('id')),
+	* }));
 	* ```
 	*
 	* `join` is a method for SQL `JOIN`, which is equivalent to `INNER JOIN`, `LEFT INNERT JOIN`.
@@ -10390,7 +10370,7 @@ var QueryJoin = class {
 	* ```ts
 	* db.user.join(
 	*   db.message,
-	*   // `sql` can be imported from your `BaseTable` file
+	*   // `sql` can be imported from your table factory file
 	*   sql`lower("message"."text") = lower("user"."name")`,
 	* );
 	* ```
@@ -11486,6 +11466,7 @@ function _orCreate(query, data, updateData, mergeData) {
 	const { q } = query;
 	q.returnsOne = true;
 	if (!q.select) q.returnType = "void";
+	q.type = "upsert";
 	if (typeof data === "function") q.upsertInsert = () => mergeData ? {
 		...mergeData,
 		...data(updateData)
@@ -12475,6 +12456,16 @@ const _appendQuery = (main, append, asFn) => {
 const _appendQueryOnUpsertCreate = (main, append, asFn) => {
 	return pushQueryValueImmutable(pushQueryValueImmutable(main, "upsertCreateAppendQueries", prepareSubQueryForSql(main, append)), "upsertCreateAsFns", asFn);
 };
+const _onUpsertUpdate = (q, asFn) => {
+	return pushQueryValueImmutable(q, "upsertUpdateAsFns", asFn);
+};
+const _prependWithOnUpsertCreate = (q, name, query) => {
+	const prev = q.q.with;
+	q.q.with = q.q.upsertCreateWith;
+	_prependWith(q, name, query);
+	q.q.upsertCreateWith = q.q.with;
+	q.q.with = prev;
+};
 const mergableObjects = new Set([
 	"selectShape",
 	"withShapes",
@@ -12698,12 +12689,12 @@ var SearchMethods = class {
 	*
 	* By default, the search language is English.
 	*
-	* You can set a different default language in the `createBaseTable` config:
+	* You can set a different default language in the `createTableFactory` config:
 	*
 	* ```ts
-	* import { createBaseTable } from 'orchid-orm';
+	* import { createTableFactory } from 'orchid-orm';
 	*
-	* export const BaseTable = createBaseTable({
+	* export const { defineTable, defineView, sql } = createTableFactory({
 	*   language: 'swedish',
 	* });
 	* ```
@@ -13089,20 +13080,20 @@ const _softDelete = (column, customNowSQL) => {
 * All queries on such table will filter out deleted records by default.
 *
 * ```ts
-* import { BaseTable } from './baseTable';
-*
-* export class SomeTable extends BaseTable {
-*   readonly table = 'some';
-*   columns = this.setColumns((t) => ({
-*     id: t.identity().primaryKey(),
-*     deletedAt: t.timestamp().nullable(),
-*   }));
+* import { defineTable } from './table-factory';
 *
+* export const SomeTable = defineTable('some', (t) => ({
+*   id: t.identity().primaryKey(),
+*   deletedAt: t.timestamp().nullable(),
+* }))
 *   // true is for using `deletedAt` column
-*   readonly softDelete = true;
-*   // or provide a different column name
-*   readonly softDelete = 'myDeletedAt';
-* }
+*   .softDelete();
+*
+* // or provide a different column name
+* export const OtherTable = defineTable('other', (t) => ({
+*   id: t.identity().primaryKey(),
+*   myDeletedAt: t.timestamp().nullable(),
+* })).softDelete('myDeletedAt');
 *
 * const db = orchidORM(
 *   { databaseURL: '...' },
@@ -14399,11 +14390,14 @@ function getColumnInfo(query, column) {
 	};
 	return q;
 }
+const columnsSql = (shape, columns) => {
+	return columns.map((item) => `"${shape[item]?.data.name || item}"`).join(", ");
+};
 const makeCopySql = (table, copy) => {
 	const ctx = newToSqlCtx(table);
 	const { q } = table;
 	const quotedAs = `"${q.as || table.table}"`;
-	const columns = copy.columns ? `(${copy.columns.map((item) => `"${table.shape[item]?.data.name || item}"`).join(", ")})` : "";
+	const columns = copy.columns ? `(${columnsSql(table.shape, copy.columns)})` : "";
 	const target = "from" in copy ? copy.from : copy.to;
 	const quotedTable = quoteTableWithSchema(table);
 	ctx.sql.push(`COPY ${quotedTable}${columns} ${"from" in copy ? "FROM" : "TO"} ${typeof target === "string" ? escapeString(target) : `PROGRAM ${escapeString(target.program)}`}`);
@@ -14416,9 +14410,9 @@ const makeCopySql = (table, copy) => {
 		if (copy.header) options.push(`HEADER ${copy.header}`);
 		if (copy.quote) options.push(`QUOTE ${escapeString(copy.quote)}`);
 		if (copy.escape) options.push(`ESCAPE ${escapeString(copy.escape)}`);
-		if (copy.forceQuote) options.push(`FORCE_QUOTE ${copy.forceQuote === "*" ? "*" : `(${copy.forceQuote.map((x) => `"${x}"`).join(", ")})`}`);
-		if (copy.forceNotNull) options.push(`FORCE_NOT_NULL (${copy.forceNotNull.map((x) => `"${x}"`).join(", ")})`);
-		if (copy.forceNull) options.push(`FORCE_NULL (${copy.forceNull.map((x) => `"${x}"`).join(", ")})`);
+		if (copy.forceQuote) options.push(`FORCE_QUOTE ${copy.forceQuote === "*" ? "*" : `(${columnsSql(table.shape, copy.forceQuote)})`}`);
+		if (copy.forceNotNull) options.push(`FORCE_NOT_NULL (${columnsSql(table.shape, copy.forceNotNull)})`);
+		if (copy.forceNull) options.push(`FORCE_NULL (${columnsSql(table.shape, copy.forceNull)})`);
 		if (copy.encoding) options.push(`ENCODING ${escapeString(copy.encoding)}`);
 		ctx.sql.push(`WITH (${options.join(", ")})`);
 	}
@@ -14609,8 +14603,10 @@ exports._clone = _clone;
 exports._createDbSqlMethod = _createDbSqlMethod;
 exports._hookSelectColumns = _hookSelectColumns;
 exports._initQueryBuilder = _initQueryBuilder;
+exports._onUpsertUpdate = _onUpsertUpdate;
 exports._orCreate = _orCreate;
 exports._prependWith = _prependWith;
+exports._prependWithOnUpsertCreate = _prependWithOnUpsertCreate;
 exports._queryCreate = _queryCreate;
 exports._queryCreateMany = _queryCreateMany;
 exports._queryCreateManyFrom = _queryCreateManyFrom;
@@ -14644,6 +14640,7 @@ exports.codeToString = codeToString;
 exports.colors = colors;
 exports.columnsShapeToCode = columnsShapeToCode;
 exports.constraintInnerToCode = constraintInnerToCode;
+exports.constraintToCode = constraintToCode;
 exports.consumeColumnName = consumeColumnName;
 exports.copyTableData = copyTableData;
 exports.createDbWithAdapter = createDbWithAdapter;
@@ -14654,6 +14651,7 @@ exports.emptyObject = emptyObject;
 exports.escapeForMigration = escapeForMigration;
 exports.escapeString = escapeString;
 exports.excludeInnerToCode = excludeInnerToCode;
+exports.excludeToCode = excludeToCode;
 exports.exhaustive = exhaustive;
 exports.getCallerFilePath = getCallerFilePath;
 exports.getClonedQueryData = getClonedQueryData;
@@ -14674,6 +14672,7 @@ exports.getSqlText = getSqlText;
 exports.getStackTrace = getStackTrace;
 exports.getSupportedDefaultPrivileges = getSupportedDefaultPrivileges;
 exports.indexInnerToCode = indexInnerToCode;
+exports.indexToCode = indexToCode;
 exports.internalSchemaConfig = internalSchemaConfig;
 exports.isExpression = isExpression;
 exports.isQueryReturnsAll = isQueryReturnsAll;