kysely 0.27.5 → 0.28.0

package/dist/esm/dialect/postgres/postgres-driver.js

@@ -1,6 +1,8 @@
 /// <reference types="./postgres-driver.d.ts" />
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { isFunction, freeze } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
 import { extendStackTrace } from '../../util/stack-trace-utils.js';
 const PRIVATE_RELEASE_METHOD = Symbol();
 export class PostgresDriver {
@@ -36,8 +38,15 @@ export class PostgresDriver {
         return connection;
     }
     async beginTransaction(connection, settings) {
-        if (settings.isolationLevel) {
-            await connection.executeQuery(CompiledQuery.raw(`start transaction isolation level ${settings.isolationLevel}`));
+        if (settings.isolationLevel || settings.accessMode) {
+            let sql = 'start transaction';
+            if (settings.isolationLevel) {
+                sql += ` isolation level ${settings.isolationLevel}`;
+            }
+            if (settings.accessMode) {
+                sql += ` ${settings.accessMode}`;
+            }
+            await connection.executeQuery(CompiledQuery.raw(sql));
         }
         else {
             await connection.executeQuery(CompiledQuery.raw('begin'));
@@ -49,6 +58,15 @@ export class PostgresDriver {
     async rollbackTransaction(connection) {
         await connection.executeQuery(CompiledQuery.raw('rollback'));
     }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release', savepointName), createQueryId()));
+    }
     async releaseConnection(connection) {
         connection[PRIVATE_RELEASE_METHOD]();
     }
@@ -69,23 +87,15 @@ class PostgresConnection {
     }
     async executeQuery(compiledQuery) {
         try {
-            const result = await this.#client.query(compiledQuery.sql, [
-                ...compiledQuery.parameters,
-            ]);
-            if (result.command === 'INSERT' ||
-                result.command === 'UPDATE' ||
-                result.command === 'DELETE' ||
-                result.command === 'MERGE') {
-                const numAffectedRows = BigInt(result.rowCount);
-                return {
-                    // TODO: remove.
-                    numUpdatedOrDeletedRows: numAffectedRows,
-                    numAffectedRows,
-                    rows: result.rows ?? [],
-                };
-            }
+            const { command, rowCount, rows } = await this.#client.query(compiledQuery.sql, [...compiledQuery.parameters]);
             return {
-                rows: result.rows ?? [],
+                numAffectedRows: command === 'INSERT' ||
+                    command === 'UPDATE' ||
+                    command === 'DELETE' ||
+                    command === 'MERGE'
+                    ? BigInt(rowCount)
+                    : undefined,
+                rows: rows ?? [],
             };
         }
         catch (err) {

package/dist/esm/dialect/postgres/postgres-introspector.js

@@ -37,23 +37,13 @@ export class PostgresIntrospector {
             'typ.typname as type',
             'dtns.nspname as type_schema',
             sql `col_description(a.attrelid, a.attnum)`.as('column_description'),
-            // Detect if the column is auto incrementing by finding the sequence
-            // that is created for `serial` and `bigserial` columns.
-            this.#db
-                .selectFrom('pg_class')
-                .select(sql `true`.as('auto_incrementing'))
-                // Make sure the sequence is in the same schema as the table.
-                .whereRef('relnamespace', '=', 'c.relnamespace')
-                .where('relkind', '=', 'S')
-                .where('relname', '=', sql `c.relname || '_' || a.attname || '_seq'`)
-                .as('auto_incrementing'),
+            sql `pg_get_serial_sequence(ns.nspname || '.' || c.relname, a.attname)`.as('auto_incrementing'),
+        ])
+            .where('c.relkind', 'in', [
+            'r' /*regular table*/,
+            'v' /*view*/,
+            'p' /*partitioned table*/,
         ])
-            // r == normal table
-            .where((eb) => eb.or([
-            eb('c.relkind', '=', 'r'),
-            eb('c.relkind', '=', 'v'),
-            eb('c.relkind', '=', 'p'),
-        ]))
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns
@@ -93,7 +83,7 @@ export class PostgresIntrospector {
                 dataType: it.type,
                 dataTypeSchema: it.type_schema,
                 isNullable: !it.not_null,
-                isAutoIncrementing: !!it.auto_incrementing,
+                isAutoIncrementing: it.auto_incrementing !== null,
                 hasDefaultValue: it.has_default,
                 comment: it.column_description ?? undefined,
             }));

package/dist/esm/dialect/sqlite/sqlite-driver.d.ts

@@ -1,5 +1,6 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
 import { Driver } from '../../driver/driver.js';
+import { QueryCompiler } from '../../query-compiler/query-compiler.js';
 import { SqliteDialectConfig } from './sqlite-dialect-config.js';
 export declare class SqliteDriver implements Driver {
     #private;
@@ -27,6 +28,9 @@ export declare class SqliteDriver implements Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
     /**
      * Releases a connection back to the pool.
      */

package/dist/esm/dialect/sqlite/sqlite-driver.js

@@ -1,7 +1,9 @@
 /// <reference types="./sqlite-driver.d.ts" />
 import { SelectQueryNode } from '../../operation-node/select-query-node.js';
+import { parseSavepointCommand } from '../../parser/savepoint-parser.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
 import { freeze, isFunction } from '../../util/object-utils.js';
+import { createQueryId } from '../../util/query-id.js';
 export class SqliteDriver {
     #config;
     #connectionMutex = new ConnectionMutex();
@@ -34,6 +36,15 @@ export class SqliteDriver {
     async rollbackTransaction(connection) {
         await connection.executeQuery(CompiledQuery.raw('rollback'));
     }
+    async savepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('savepoint', savepointName), createQueryId()));
+    }
+    async rollbackToSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('rollback to', savepointName), createQueryId()));
+    }
+    async releaseSavepoint(connection, savepointName, compileQuery) {
+        await connection.executeQuery(compileQuery(parseSavepointCommand('release', savepointName), createQueryId()));
+    }
     async releaseConnection() {
         this.#connectionMutex.unlock();
     }
@@ -54,19 +65,14 @@ class SqliteConnection {
                 rows: stmt.all(parameters),
             });
         }
-        else {
-            const { changes, lastInsertRowid } = stmt.run(parameters);
-            const numAffectedRows = changes !== undefined && changes !== null ? BigInt(changes) : undefined;
-            return Promise.resolve({
-                // TODO: remove.
-                numUpdatedOrDeletedRows: numAffectedRows,
-                numAffectedRows,
-                insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
-                    ? BigInt(lastInsertRowid)
-                    : undefined,
-                rows: [],
-            });
-        }
+        const { changes, lastInsertRowid } = stmt.run(parameters);
+        return Promise.resolve({
+            numAffectedRows: changes !== undefined && changes !== null ? BigInt(changes) : undefined,
+            insertId: lastInsertRowid !== undefined && lastInsertRowid !== null
+                ? BigInt(lastInsertRowid)
+                : undefined,
+            rows: [],
+        });
     }
     async *streamQuery(compiledQuery, _chunkSize) {
         const { sql, parameters, query } = compiledQuery;

package/dist/esm/dialect/sqlite/sqlite-introspector.js

@@ -11,58 +11,80 @@ export class SqliteIntrospector {
         return [];
     }
     async getTables(options = { withInternalKyselyTables: false }) {
-        let query = this.#db
+        return await this.#getTableMetadata(options);
+    }
+    async getMetadata(options) {
+        return {
+            tables: await this.getTables(options),
+        };
+    }
+    #tablesQuery(qb, options) {
+        let tablesQuery = qb
             .selectFrom('sqlite_master')
             .where('type', 'in', ['table', 'view'])
             .where('name', 'not like', 'sqlite_%')
-            .select('name')
-            .orderBy('name')
-            .$castTo();
+            .select(['name', 'sql', 'type'])
+            .orderBy('name');
         if (!options.withInternalKyselyTables) {
-            query = query
+            tablesQuery = tablesQuery
                 .where('name', '!=', DEFAULT_MIGRATION_TABLE)
                 .where('name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
-        const tables = await query.execute();
-        return Promise.all(tables.map(({ name }) => this.#getTableMetadata(name)));
+        return tablesQuery;
     }
-    async getMetadata(options) {
-        return {
-            tables: await this.getTables(options),
-        };
-    }
-    async #getTableMetadata(table) {
-        const db = this.#db;
-        // Get the SQL that was used to create the table.
-        const tableDefinition = await db
-            .selectFrom('sqlite_master')
-            .where('name', '=', table)
-            .select(['sql', 'type'])
-            .$castTo()
-            .executeTakeFirstOrThrow();
-        // Try to find the name of the column that has `autoincrement` 🤦
-        const autoIncrementCol = tableDefinition.sql
-            ?.split(/[\(\),]/)
-            ?.find((it) => it.toLowerCase().includes('autoincrement'))
-            ?.trimStart()
-            ?.split(/\s+/)?.[0]
-            ?.replace(/["`]/g, '');
-        const columns = await db
-            .selectFrom(sql `pragma_table_info(${table})`.as('table_info'))
-            .select(['name', 'type', 'notnull', 'dflt_value'])
-            .orderBy('cid')
+    async #getTableMetadata(options) {
+        const tablesResult = await this.#tablesQuery(this.#db, options).execute();
+        const tableMetadata = await this.#db
+            .with('table_list', (qb) => this.#tablesQuery(qb, options))
+            .selectFrom([
+            'table_list as tl',
+            sql `pragma_table_info(tl.name)`.as('p'),
+        ])
+            .select([
+            'tl.name as table',
+            'p.cid',
+            'p.name',
+            'p.type',
+            'p.notnull',
+            'p.dflt_value',
+            'p.pk',
+        ])
+            .orderBy(['tl.name', 'p.cid'])
             .execute();
-        return {
-            name: table,
-            isView: tableDefinition.type === 'view',
-            columns: columns.map((col) => ({
-                name: col.name,
-                dataType: col.type,
-                isNullable: !col.notnull,
-                isAutoIncrementing: col.name === autoIncrementCol,
-                hasDefaultValue: col.dflt_value != null,
-                comment: undefined,
-            })),
-        };
+        const columnsByTable = {};
+        for (const row of tableMetadata) {
+            columnsByTable[row.table] ??= [];
+            columnsByTable[row.table].push(row);
+        }
+        return tablesResult.map(({ name, sql, type }) => {
+            // // Try to find the name of the column that has `autoincrement` 🤦
+            let autoIncrementCol = sql
+                ?.split(/[\(\),]/)
+                ?.find((it) => it.toLowerCase().includes('autoincrement'))
+                ?.trimStart()
+                ?.split(/\s+/)?.[0]
+                ?.replace(/["`]/g, '');
+            const columns = columnsByTable[name] ?? [];
+            // Otherwise, check for an INTEGER PRIMARY KEY
+            // https://www.sqlite.org/autoinc.html
+            if (!autoIncrementCol) {
+                const pkCols = columns.filter((r) => r.pk > 0);
+                if (pkCols.length === 1 && pkCols[0].type.toLowerCase() === 'integer') {
+                    autoIncrementCol = pkCols[0].name;
+                }
+            }
+            return {
+                name: name,
+                isView: type === 'view',
+                columns: columns.map((col) => ({
+                    name: col.name,
+                    dataType: col.type,
+                    isNullable: !col.notnull,
+                    isAutoIncrementing: col.name === autoIncrementCol,
+                    hasDefaultValue: col.dflt_value != null,
+                    comment: undefined,
+                })),
+            };
+        });
     }
 }

package/dist/esm/dialect/sqlite/sqlite-query-compiler.d.ts

@@ -1,6 +1,8 @@
 import { DefaultInsertValueNode } from '../../operation-node/default-insert-value-node.js';
+import { OrActionNode } from '../../operation-node/or-action-node.js';
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 export declare class SqliteQueryCompiler extends DefaultQueryCompiler {
+    protected visitOrAction(node: OrActionNode): void;
     protected getCurrentParameterPlaceholder(): string;
     protected getLeftExplainOptionsWrapper(): string;
     protected getRightExplainOptionsWrapper(): string;

package/dist/esm/dialect/sqlite/sqlite-query-compiler.js

@@ -2,6 +2,10 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
 const ID_WRAP_REGEX = /"/g;
 export class SqliteQueryCompiler extends DefaultQueryCompiler {
+    visitOrAction(node) {
+        this.append('or ');
+        this.append(node.action);
+    }
     getCurrentParameterPlaceholder() {
         return '?';
     }

package/dist/esm/driver/database-connection.d.ts

@@ -9,10 +9,6 @@ export interface DatabaseConnection {
     streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
 }
 export interface QueryResult<O> {
-    /**
-     * @deprecated use {@link QueryResult.numAffectedRows} instead.
-     */
-    readonly numUpdatedOrDeletedRows?: bigint;
     /**
      * This is defined for insert, update, delete and merge queries and contains
      * the number of rows the query inserted/updated/deleted.

package/dist/esm/driver/driver.d.ts

@@ -1,3 +1,4 @@
+import { QueryCompiler } from '../query-compiler/query-compiler.js';
 import { ArrayItemType } from '../util/type-utils.js';
 import { DatabaseConnection } from './database-connection.js';
 /**
@@ -28,6 +29,18 @@ export interface Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    /**
+     * Establishses a new savepoint within a transaction.
+     */
+    savepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Rolls back to a savepoint within a transaction.
+     */
+    rollbackToSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    /**
+     * Releases a savepoint within a transaction.
+     */
+    releaseSavepoint?(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
     /**
      * Releases a connection back to the pool.
      */
@@ -38,7 +51,11 @@ export interface Driver {
     destroy(): Promise<void>;
 }
 export interface TransactionSettings {
+    readonly accessMode?: AccessMode;
     readonly isolationLevel?: IsolationLevel;
 }
+export declare const TRANSACTION_ACCESS_MODES: readonly ["read only", "read write"];
+export type AccessMode = ArrayItemType<typeof TRANSACTION_ACCESS_MODES>;
 export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable", "snapshot"];
 export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;
+export declare function validateTransactionSettings(settings: TransactionSettings): void;

package/dist/esm/driver/driver.js

@@ -1,4 +1,5 @@
 /// <reference types="./driver.d.ts" />
+export const TRANSACTION_ACCESS_MODES = ['read only', 'read write'];
 export const TRANSACTION_ISOLATION_LEVELS = [
     'read uncommitted',
     'read committed',
@@ -6,3 +7,13 @@ export const TRANSACTION_ISOLATION_LEVELS = [
     'serializable',
     'snapshot',
 ];
+export function validateTransactionSettings(settings) {
+    if (settings.accessMode &&
+        !TRANSACTION_ACCESS_MODES.includes(settings.accessMode)) {
+        throw new Error(`invalid transaction access mode ${settings.accessMode}`);
+    }
+    if (settings.isolationLevel &&
+        !TRANSACTION_ISOLATION_LEVELS.includes(settings.isolationLevel)) {
+        throw new Error(`invalid transaction isolation level ${settings.isolationLevel}`);
+    }
+}

package/dist/esm/driver/dummy-driver.d.ts

@@ -69,4 +69,7 @@ export declare class DummyDriver implements Driver {
      * Destroys the driver and releases all resources.
      */
     destroy(): Promise<void>;
+    releaseSavepoint(): Promise<void>;
+    rollbackToSavepoint(): Promise<void>;
+    savepoint(): Promise<void>;
 }

package/dist/esm/driver/dummy-driver.js

@@ -58,6 +58,15 @@ export class DummyDriver {
     async destroy() {
         // Nothing to do here.
     }
+    async releaseSavepoint() {
+        // Nothing to do here.
+    }
+    async rollbackToSavepoint() {
+        // Nothing to do here.
+    }
+    async savepoint() {
+        // Nothing to do here.
+    }
 }
 class DummyConnection {
     async executeQuery() {

package/dist/esm/driver/runtime-driver.d.ts

@@ -1,3 +1,4 @@
+import { QueryCompiler } from '../query-compiler/query-compiler.js';
 import { Log } from '../util/log.js';
 import { DatabaseConnection } from './database-connection.js';
 import { Driver, TransactionSettings } from './driver.js';
@@ -36,6 +37,9 @@ export declare class RuntimeDriver implements Driver {
      * Rolls back a transaction.
      */
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;
+    savepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    rollbackToSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
+    releaseSavepoint(connection: DatabaseConnection, savepointName: string, compileQuery: QueryCompiler['compileQuery']): Promise<void>;
     /**
      * Destroys the driver and releases all resources.
      */

package/dist/esm/driver/runtime-driver.js

@@ -62,6 +62,24 @@ export class RuntimeDriver {
     rollbackTransaction(connection) {
         return this.#driver.rollbackTransaction(connection);
     }
+    savepoint(connection, savepointName, compileQuery) {
+        if (this.#driver.savepoint) {
+            return this.#driver.savepoint(connection, savepointName, compileQuery);
+        }
+        throw new Error('The `savepoint` method is not supported by this driver');
+    }
+    rollbackToSavepoint(connection, savepointName, compileQuery) {
+        if (this.#driver.rollbackToSavepoint) {
+            return this.#driver.rollbackToSavepoint(connection, savepointName, compileQuery);
+        }
+        throw new Error('The `rollbackToSavepoint` method is not supported by this driver');
+    }
+    releaseSavepoint(connection, savepointName, compileQuery) {
+        if (this.#driver.releaseSavepoint) {
+            return this.#driver.releaseSavepoint(connection, savepointName, compileQuery);
+        }
+        throw new Error('The `releaseSavepoint` method is not supported by this driver');
+    }
     async destroy() {
         if (!this.#initPromise) {
             return;
@@ -83,6 +101,8 @@ export class RuntimeDriver {
     // the best option in this case.
     #addLogging(connection) {
         const executeQuery = connection.executeQuery;
+        const streamQuery = connection.streamQuery;
+        const dis = this;
         connection.executeQuery = async (compiledQuery) => {
             let caughtError;
             const startTime = performanceNow();
@@ -91,12 +111,31 @@ export class RuntimeDriver {
             }
             catch (error) {
                 caughtError = error;
-                await this.#logError(error, compiledQuery, startTime);
+                await dis.#logError(error, compiledQuery, startTime);
+                throw error;
+            }
+            finally {
+                if (!caughtError) {
+                    await dis.#logQuery(compiledQuery, startTime);
+                }
+            }
+        };
+        connection.streamQuery = async function* (compiledQuery, chunkSize) {
+            let caughtError;
+            const startTime = performanceNow();
+            try {
+                for await (const result of streamQuery.call(connection, compiledQuery, chunkSize)) {
+                    yield result;
+                }
+            }
+            catch (error) {
+                caughtError = error;
+                await dis.#logError(error, compiledQuery, startTime);
                 throw error;
             }
             finally {
                 if (!caughtError) {
-                    await this.#logQuery(compiledQuery, startTime);
+                    await dis.#logQuery(compiledQuery, startTime, true);
                 }
             }
         };
@@ -109,9 +148,10 @@ export class RuntimeDriver {
             queryDurationMillis: this.#calculateDurationMillis(startTime),
         }));
     }
-    async #logQuery(compiledQuery, startTime) {
+    async #logQuery(compiledQuery, startTime, isStream = false) {
         await this.#log.query(() => ({
             level: 'query',
+            isStream,
             query: compiledQuery,
             queryDurationMillis: this.#calculateDurationMillis(startTime),
         }));

package/dist/esm/expression/expression-builder.d.ts

@@ -1,5 +1,5 @@
 import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
-import { TableExpression, From, FromTables, ExtractTableAlias, AnyAliasedTable, PickTableWithAlias } from '../parser/table-parser.js';
+import { TableExpressionOrList } from '../parser/table-parser.js';
 import { FunctionModule } from '../query-builder/function-module.js';
 import { ExtractTypeFromReferenceExpression, ReferenceExpression, SimpleReferenceExpression, StringReference } from '../parser/reference-parser.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
@@ -16,6 +16,7 @@ import { RefTuple2, RefTuple3, RefTuple4, RefTuple5, ValTuple2, ValTuple3, ValTu
 import { Selectable } from '../util/column-type.js';
 import { KyselyTypeError } from '../util/type-error.js';
 import { DataTypeExpression } from '../parser/data-type-parser.js';
+import { SelectFrom } from '../parser/select-from-parser.js';
 export interface ExpressionBuilder<DB, TB extends keyof DB> {
     /**
      * Creates a binary expression.
@@ -116,9 +117,9 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * ```ts
      * const result = await db.selectFrom('person')
      *   .where(({ eb, exists, selectFrom }) =>
-     *     eb('first_name', '=', 'Jennifer').and(
-     *       exists(selectFrom('pet').whereRef('owner_id', '=', 'person.id').select('pet.id'))
-     *     )
+     *     eb('first_name', '=', 'Jennifer').and(exists(
+     *       selectFrom('pet').whereRef('owner_id', '=', 'person.id').select('pet.id')
+     *     ))
      *   )
      *   .selectAll()
      *   .execute()
@@ -209,11 +210,7 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * that case Kysely typings wouldn't allow you to reference `pet.owner_id`
      * because `pet` is not joined to that query.
      */
-    selectFrom<TE extends keyof DB & string>(from: TE[]): SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, TB>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
-    selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, TB | ExtractTableAlias<DB, TE>, {}>;
-    selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, TB | ExtractTableAlias<DB & PickTableWithAlias<DB, TE>, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, TB>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, TB, TE>, {}>;
+    selectFrom<TE extends TableExpressionOrList<DB, TB>>(from: TE): SelectFrom<DB, TB, TE>;
     /**
      * Creates a `case` statement/operator.
      *
@@ -444,6 +441,8 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
      * inner join "pet" on "pet"."owner_id" = "person"."id"
      * group by "person"."id"
      * ```
+     *
+     * If you need a column reference, use {@link ref}.
      */
     table<T extends TB & string>(table: T): ExpressionWrapper<DB, TB, Selectable<DB[T]>>;
     /**
@@ -918,4 +917,4 @@ export interface ExpressionBuilder<DB, TB extends keyof DB> {
 }
 export declare function createExpressionBuilder<DB, TB extends keyof DB>(executor?: QueryExecutor): ExpressionBuilder<DB, TB>;
 export declare function expressionBuilder<DB, TB extends keyof DB>(_: SelectQueryBuilder<DB, TB, any>): ExpressionBuilder<DB, TB>;
-export declare function expressionBuilder<DB, TB extends keyof DB>(): ExpressionBuilder<DB, TB>;
+export declare function expressionBuilder<DB, TB extends keyof DB = never>(): ExpressionBuilder<DB, TB>;

package/dist/esm/helpers/postgres.d.ts

@@ -149,3 +149,51 @@ export declare function jsonObjectFrom<O>(expr: Expression<O>): RawBuilder<Simpl
 export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
     [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
 }>>;
+export type MergeAction = 'INSERT' | 'UPDATE' | 'DELETE';
+/**
+ * The PostgreSQL `merge_action` function.
+ *
+ * This function can be used in a `returning` clause to get the action that was
+ * performed in a `mergeInto` query. The function returns one of the following
+ * strings: `'INSERT'`, `'UPDATE'`, or `'DELETE'`.
+ *
+ * ### Examples
+ *
+ * ```ts
+ * import { mergeAction } from 'kysely/helpers/postgres'
+ *
+ * const result = await db
+ *   .mergeInto('person as p')
+ *   .using('person_backup as pb', 'p.id', 'pb.id')
+ *   .whenMatched()
+ *   .thenUpdateSet(({ ref }) => ({
+ *     first_name: ref('pb.first_name'),
+ *     updated_at: ref('pb.updated_at').$castTo<string | null>(),
+ *   }))
+ *   .whenNotMatched()
+ *   .thenInsertValues(({ ref}) => ({
+ *     id: ref('pb.id'),
+ *     first_name: ref('pb.first_name'),
+ *     created_at: ref('pb.updated_at'),
+ *     updated_at: ref('pb.updated_at').$castTo<string | null>(),
+ *   }))
+ *   .returning([mergeAction().as('action'), 'p.id', 'p.updated_at'])
+ *   .execute()
+ *
+ * result[0].action
+ * ```
+ *
+ * The generated SQL (PostgreSQL):
+ *
+ * ```sql
+ * merge into "person" as "p"
+ * using "person_backup" as "pb" on "p"."id" = "pb"."id"
+ * when matched then update set
+ *   "first_name" = "pb"."first_name",
+ *   "updated_at" = "pb"."updated_at"::text
+ * when not matched then insert values ("id", "first_name", "created_at", "updated_at")
+ * values ("pb"."id", "pb"."first_name", "pb"."updated_at", "pb"."updated_at")
+ * returning merge_action() as "action", "p"."id", "p"."updated_at"
+ * ```
+ */
+export declare function mergeAction(): RawBuilder<MergeAction>;