kysely 0.27.6 → 0.28.0

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

@@ -12,11 +12,13 @@ import { DropViewNode } from '../operation-node/drop-view-node.js';
 import { MergeQueryNode } from '../operation-node/merge-query-node.js';
 import { QueryNode } from '../operation-node/query-node.js';
 import { RawNode } from '../operation-node/raw-node.js';
+import { RefreshMaterializedViewNode } from '../operation-node/refresh-materialized-view-node.js';
+import { QueryId } from '../util/query-id.js';
 import { CompiledQuery } from './compiled-query.js';
-export type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode | MergeQueryNode;
+export type RootOperationNode = QueryNode | CreateTableNode | CreateIndexNode | CreateSchemaNode | CreateViewNode | RefreshMaterializedViewNode | DropTableNode | DropIndexNode | DropSchemaNode | DropViewNode | AlterTableNode | RawNode | CreateTypeNode | DropTypeNode | MergeQueryNode;
 /**
  * a `QueryCompiler` compiles a query expressed as a tree of `OperationNodes` into SQL.
  */
 export interface QueryCompiler {
-    compileQuery(node: RootOperationNode): CompiledQuery;
+    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
 }

package/dist/esm/query-creator.d.ts

@@ -1,19 +1,17 @@
 import { SelectQueryBuilder } from './query-builder/select-query-builder.js';
 import { InsertQueryBuilder } from './query-builder/insert-query-builder.js';
-import { DeleteQueryBuilder } from './query-builder/delete-query-builder.js';
-import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
-import { TableExpression, From, FromTables, TableReference, ExtractTableAlias, AnyAliasedTable, PickTableWithAlias } from './parser/table-parser.js';
+import { TableExpressionOrList, SimpleTableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { InsertResult } from './query-builder/insert-result.js';
-import { DeleteResult } from './query-builder/delete-result.js';
-import { UpdateResult } from './query-builder/update-result.js';
 import { KyselyPlugin } from './plugin/kysely-plugin.js';
 import { CTEBuilderCallback } from './query-builder/cte-builder.js';
 import { CallbackSelection, SelectCallback, SelectExpression, Selection } from './parser/select-parser.js';
-import { MergeQueryBuilder } from './query-builder/merge-query-builder.js';
-import { MergeResult } from './query-builder/merge-result.js';
+import { SelectFrom } from './parser/select-from-parser.js';
+import { DeleteFrom } from './parser/delete-from-parser.js';
+import { UpdateTable } from './parser/update-parser.js';
+import { MergeInto } from './parser/merge-into-parser.js';
 export declare class QueryCreator<DB> {
     #private;
     constructor(props: QueryCreatorProps);
@@ -124,11 +122,7 @@ export declare class QueryCreator<DB> {
      *   (select 1 as one) as "q"
      * ```
      */
-    selectFrom<TE extends keyof DB & string>(from: TE[]): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, never>>(from: TE[]): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
-    selectFrom<TE extends keyof DB & string>(from: TE): SelectQueryBuilder<DB, ExtractTableAlias<DB, TE>, {}>;
-    selectFrom<TE extends AnyAliasedTable<DB>>(from: TE): SelectQueryBuilder<DB & PickTableWithAlias<DB, TE>, ExtractTableAlias<DB & PickTableWithAlias<DB, TE>, TE>, {}>;
-    selectFrom<TE extends TableExpression<DB, never>>(from: TE): SelectQueryBuilder<From<DB, TE>, FromTables<DB, never, TE>, {}>;
+    selectFrom<TE extends TableExpressionOrList<DB, never>>(from: TE): SelectFrom<DB, never, TE>;
     /**
      * Creates a `select` query builder without a `from` clause.
      *
@@ -218,10 +212,14 @@ export declare class QueryCreator<DB> {
      */
     insertInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
-     * Creates a replace query.
+     * Creates a "replace into" query.
      *
-     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
-     * that deletes and inserts values on collision instead of updating existing rows.
+     * This is only supported by some dialects like MySQL or SQLite.
+     *
+     * Similar to MySQL's {@link InsertQueryBuilder.onDuplicateKeyUpdate} that deletes
+     * and inserts values on collision instead of updating existing rows.
+     *
+     * An alias of SQLite's {@link InsertQueryBuilder.orReplace}.
      *
      * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
      * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
@@ -238,10 +236,16 @@ export declare class QueryCreator<DB> {
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
      *
      * console.log(result.insertId)
      * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * replace into `person` (`first_name`, `last_name`) values (?, ?)
+     * ```
      */
     replaceInto<T extends keyof DB & string>(table: T): InsertQueryBuilder<DB, T, InsertResult>;
     /**
@@ -293,10 +297,7 @@ export declare class QueryCreator<DB> {
      * where `person`.`id` = ?
      * ```
      */
-    deleteFrom<TR extends keyof DB & string>(from: TR[]): DeleteQueryBuilder<DB, ExtractTableAlias<DB, TR>, DeleteResult>;
-    deleteFrom<TR extends TableReference<DB>>(tables: TR[]): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
-    deleteFrom<TR extends keyof DB & string>(from: TR): DeleteQueryBuilder<DB, ExtractTableAlias<DB, TR>, DeleteResult>;
-    deleteFrom<TR extends TableReference<DB>>(table: TR): DeleteQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, DeleteResult>;
+    deleteFrom<TE extends TableExpressionOrList<DB, never>>(from: TE): DeleteFrom<DB, TE>;
     /**
      * Creates an update query.
      *
@@ -320,9 +321,7 @@ export declare class QueryCreator<DB> {
      * console.log(result.numUpdatedRows)
      * ```
      */
-    updateTable<TR extends keyof DB & string>(table: TR): UpdateQueryBuilder<DB, ExtractTableAlias<DB, TR>, ExtractTableAlias<DB, TR>, UpdateResult>;
-    updateTable<TR extends AnyAliasedTable<DB>>(table: TR): UpdateQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, UpdateResult>;
-    updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<From<DB, TR>, FromTables<DB, never, TR>, FromTables<DB, never, TR>, UpdateResult>;
+    updateTable<TE extends TableExpressionOrList<DB, never>>(tables: TE): UpdateTable<DB, TE>;
     /**
      * Creates a merge query.
      *
@@ -406,8 +405,7 @@ export declare class QueryCreator<DB> {
      * then delete
      * ```
      */
-    mergeInto<TR extends keyof DB & string>(targetTable: TR): MergeQueryBuilder<DB, TR, MergeResult>;
-    mergeInto<TR extends AnyAliasedTable<DB>>(targetTable: TR): MergeQueryBuilder<DB & PickTableWithAlias<DB, TR>, ExtractTableAlias<DB & PickTableWithAlias<DB, TR>, TR>, MergeResult>;
+    mergeInto<TR extends SimpleTableReference<DB>>(targetTable: TR): MergeInto<DB, TR>;
     /**
      * Creates a `with` query (Common Table Expression).
      *

package/dist/esm/query-creator.js

@@ -7,7 +7,7 @@ import { DeleteQueryNode } from './operation-node/delete-query-node.js';
 import { InsertQueryNode } from './operation-node/insert-query-node.js';
 import { SelectQueryNode } from './operation-node/select-query-node.js';
 import { UpdateQueryNode } from './operation-node/update-query-node.js';
-import { parseTable, parseTableExpression, parseTableExpressionOrList, parseAliasedTable, } from './parser/table-parser.js';
+import { parseTable, parseTableExpressionOrList, parseAliasedTable, } from './parser/table-parser.js';
 import { parseCommonTableExpression, } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { createQueryId } from './util/query-id.js';
@@ -21,6 +21,113 @@ export class QueryCreator {
     constructor(props) {
         this.#props = freeze(props);
     }
+    /**
+     * Creates a `select` query builder for the given table or tables.
+     *
+     * The tables passed to this method are built as the query's `from` clause.
+     *
+     * ### Examples
+     *
+     * Create a select query for one table:
+     *
+     * ```ts
+     * db.selectFrom('person').selectAll()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select * from "person"
+     * ```
+     *
+     * Create a select query for one table with an alias:
+     *
+     * ```ts
+     * const persons = await db.selectFrom('person as p')
+     *   .select(['p.id', 'first_name'])
+     *   .execute()
+     *
+     * console.log(persons[0].id)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "p"."id", "first_name" from "person" as "p"
+     * ```
+     *
+     * Create a select query from a subquery:
+     *
+     * ```ts
+     * const persons = await db.selectFrom(
+     *     (eb) => eb.selectFrom('person').select('person.id as identifier').as('p')
+     *   )
+     *   .select('p.identifier')
+     *   .execute()
+     *
+     * console.log(persons[0].identifier)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "p"."identifier",
+     * from (
+     *   select "person"."id" as "identifier" from "person"
+     * ) as p
+     * ```
+     *
+     * Create a select query from raw sql:
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const items = await db
+     *   .selectFrom(sql<{ one: number }>`(select 1 as one)`.as('q'))
+     *   .select('q.one')
+     *   .execute()
+     *
+     * console.log(items[0].one)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "q"."one",
+     * from (
+     *   select 1 as one
+     * ) as q
+     * ```
+     *
+     * When you use the `sql` tag you need to also provide the result type of the
+     * raw snippet / query so that Kysely can figure out what columns are
+     * available for the rest of the query.
+     *
+     * The `selectFrom` method also accepts an array for multiple tables. All
+     * the above examples can also be used in an array.
+     *
+     * ```ts
+     * import { sql } from 'kysely'
+     *
+     * const items = await db.selectFrom([
+     *     'person as p',
+     *     db.selectFrom('pet').select('pet.species').as('a'),
+     *     sql<{ one: number }>`(select 1 as one)`.as('q')
+     *   ])
+     *   .select(['p.id', 'a.species', 'q.one'])
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "p".id, "a"."species", "q"."one"
+     * from
+     *   "person" as "p",
+     *   (select "pet"."species" from "pet") as a,
+     *   (select 1 as one) as "q"
+     * ```
+     */
     selectFrom(from) {
         return createSelectQueryBuilder({
             queryId: createQueryId(),
@@ -81,10 +188,14 @@ export class QueryCreator {
         });
     }
     /**
-     * Creates a replace query.
+     * Creates a "replace into" query.
+     *
+     * This is only supported by some dialects like MySQL or SQLite.
+     *
+     * Similar to MySQL's {@link InsertQueryBuilder.onDuplicateKeyUpdate} that deletes
+     * and inserts values on collision instead of updating existing rows.
      *
-     * A MySQL-only statement similar to {@link InsertQueryBuilder.onDuplicateKeyUpdate}
-     * that deletes and inserts values on collision instead of updating existing rows.
+     * An alias of SQLite's {@link InsertQueryBuilder.orReplace}.
      *
      * The return value of this query is an instance of {@link InsertResult}. {@link InsertResult}
      * has the {@link InsertResult.insertId | insertId} field that holds the auto incremented id of
@@ -101,10 +212,16 @@ export class QueryCreator {
      *     first_name: 'Jennifer',
      *     last_name: 'Aniston'
      *   })
-     *   .executeTakeFirst()
+     *   .executeTakeFirstOrThrow()
      *
      * console.log(result.insertId)
      * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * replace into `person` (`first_name`, `last_name`) values (?, ?)
+     * ```
      */
     replaceInto(table) {
         return new InsertQueryBuilder({
@@ -113,20 +230,175 @@ export class QueryCreator {
             queryNode: InsertQueryNode.create(parseTable(table), this.#props.withNode, true),
         });
     }
-    deleteFrom(tables) {
+    /**
+     * Creates a delete query.
+     *
+     * See the {@link DeleteQueryBuilder.where} method for examples on how to specify
+     * a where clause for the delete operation.
+     *
+     * The return value of the query is an instance of {@link DeleteResult}.
+     *
+     * ### Examples
+     *
+     * <!-- siteExample("delete", "Single row", 10) -->
+     *
+     * Delete a single row:
+     *
+     * ```ts
+     * const result = await db
+     *   .deleteFrom('person')
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     *
+     * console.log(result.numDeletedRows)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * delete from "person" where "person"."id" = $1
+     * ```
+     *
+     * Some databases such as MySQL support deleting from multiple tables:
+     *
+     * ```ts
+     * const result = await db
+     *   .deleteFrom(['person', 'pet'])
+     *   .using('person')
+     *   .innerJoin('pet', 'pet.owner_id', 'person.id')
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * delete from `person`, `pet`
+     * using `person`
+     * inner join `pet` on `pet`.`owner_id` = `person`.`id`
+     * where `person`.`id` = ?
+     * ```
+     */
+    deleteFrom(from) {
         return new DeleteQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            queryNode: DeleteQueryNode.create(parseTableExpressionOrList(tables), this.#props.withNode),
+            queryNode: DeleteQueryNode.create(parseTableExpressionOrList(from), this.#props.withNode),
         });
     }
-    updateTable(table) {
+    /**
+     * Creates an update query.
+     *
+     * See the {@link UpdateQueryBuilder.where} method for examples on how to specify
+     * a where clause for the update operation.
+     *
+     * See the {@link UpdateQueryBuilder.set} method for examples on how to
+     * specify the updates.
+     *
+     * The return value of the query is an {@link UpdateResult}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const result = await db
+     *   .updateTable('person')
+     *   .set({ first_name: 'Jennifer' })
+     *   .where('person.id', '=', 1)
+     *   .executeTakeFirst()
+     *
+     * console.log(result.numUpdatedRows)
+     * ```
+     */
+    updateTable(tables) {
         return new UpdateQueryBuilder({
             queryId: createQueryId(),
             executor: this.#props.executor,
-            queryNode: UpdateQueryNode.create(parseTableExpression(table), this.#props.withNode),
+            queryNode: UpdateQueryNode.create(parseTableExpressionOrList(tables), this.#props.withNode),
         });
     }
+    /**
+     * Creates a merge query.
+     *
+     * The return value of the query is a {@link MergeResult}.
+     *
+     * See the {@link MergeQueryBuilder.using} method for examples on how to specify
+     * the other table.
+     *
+     * ### Examples
+     *
+     * <!-- siteExample("merge", "Source row existence", 10) -->
+     *
+     * Update a target column based on the existence of a source row:
+     *
+     * ```ts
+     * const result = await db
+     *   .mergeInto('person as target')
+     *   .using('pet as source', 'source.owner_id', 'target.id')
+     *   .whenMatchedAnd('target.has_pets', '!=', 'Y')
+     *   .thenUpdateSet({ has_pets: 'Y' })
+     *   .whenNotMatchedBySourceAnd('target.has_pets', '=', 'Y')
+     *   .thenUpdateSet({ has_pets: 'N' })
+     *   .executeTakeFirstOrThrow()
+     *
+     * console.log(result.numChangedRows)
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "person"
+     * using "pet"
+     * on "pet"."owner_id" = "person"."id"
+     * when matched and "has_pets" != $1
+     * then update set "has_pets" = $2
+     * when not matched by source and "has_pets" = $3
+     * then update set "has_pets" = $4
+     * ```
+     *
+     * <!-- siteExample("merge", "Temporary changes table", 20) -->
+     *
+     * Merge new entries from a temporary changes table:
+     *
+     * ```ts
+     * const result = await db
+     *   .mergeInto('wine as target')
+     *   .using(
+     *     'wine_stock_change as source',
+     *     'source.wine_name',
+     *     'target.name',
+     *   )
+     *   .whenNotMatchedAnd('source.stock_delta', '>', 0)
+     *   .thenInsertValues(({ ref }) => ({
+     *     name: ref('source.wine_name'),
+     *     stock: ref('source.stock_delta'),
+     *   }))
+     *   .whenMatchedAnd(
+     *     (eb) => eb('target.stock', '+', eb.ref('source.stock_delta')),
+     *     '>',
+     *     0,
+     *   )
+     *   .thenUpdateSet('stock', (eb) =>
+     *     eb('target.stock', '+', eb.ref('source.stock_delta')),
+     *   )
+     *   .whenMatched()
+     *   .thenDelete()
+     *   .executeTakeFirstOrThrow()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * merge into "wine" as "target"
+     * using "wine_stock_change" as "source"
+     * on "source"."wine_name" = "target"."name"
+     * when not matched and "source"."stock_delta" > $1
+     * then insert ("name", "stock") values ("source"."wine_name", "source"."stock_delta")
+     * when matched and "target"."stock" + "source"."stock_delta" > $2
+     * then update set "stock" = "target"."stock" + "source"."stock_delta"
+     * when matched
+     * then delete
+     * ```
+     */
     mergeInto(targetTable) {
         return new MergeQueryBuilder({
             queryId: createQueryId(),

package/dist/esm/query-executor/default-query-executor.d.ts

@@ -5,6 +5,7 @@ import { RootOperationNode, QueryCompiler } from '../query-compiler/query-compil
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryExecutorBase } from './query-executor-base.js';
 import { DialectAdapter } from '../dialect/dialect-adapter.js';
+import { QueryId } from '../util/query-id.js';
 export declare class DefaultQueryExecutor extends QueryExecutorBase {
     #private;
     constructor(compiler: QueryCompiler, adapter: DialectAdapter, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
@@ -17,7 +18,7 @@ export declare class DefaultQueryExecutor extends QueryExecutorBase {
      * the output of {@link transformQuery} into this method but you can
      * compile any query using this method.
      */
-    compileQuery(node: RootOperationNode): CompiledQuery;
+    compileQuery(node: RootOperationNode, queryId: QueryId): CompiledQuery;
     /**
      * Provides a connection for the callback and takes care of disposing
      * the connection after the callback has been run.

package/dist/esm/query-executor/default-query-executor.js

@@ -13,8 +13,8 @@ export class DefaultQueryExecutor extends QueryExecutorBase {
     get adapter() {
         return this.#adapter;
     }
-    compileQuery(node) {
-        return this.#compiler.compileQuery(node);
+    compileQuery(node, queryId) {
+        return this.#compiler.compileQuery(node, queryId);
     }
     provideConnection(consumer) {
         return this.#connectionProvider.provideConnection(consumer);

package/dist/esm/query-executor/query-executor-base.js

@@ -1,6 +1,6 @@
 /// <reference types="./query-executor-base.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { Deferred } from '../util/deferred.js';
+import { provideControlledConnection } from '../util/provide-controlled-connection.js';
 import { logOnce } from '../util/log-once.js';
 const NO_PLUGINS = freeze([]);
 export class QueryExecutorBase {
@@ -33,28 +33,21 @@ export class QueryExecutorBase {
     async executeQuery(compiledQuery, queryId) {
         return await this.provideConnection(async (connection) => {
             const result = await connection.executeQuery(compiledQuery);
-            const transformedResult = await this.#transformResult(result, queryId);
-            // TODO: remove.
-            warnOfOutdatedDriverOrPlugins(result, transformedResult);
-            return transformedResult;
+            if ('numUpdatedOrDeletedRows' in result) {
+                logOnce('kysely:warning: outdated driver/plugin detected! `QueryResult.numUpdatedOrDeletedRows` has been replaced with `QueryResult.numAffectedRows`.');
+            }
+            return await this.#transformResult(result, queryId);
         });
     }
     async *stream(compiledQuery, chunkSize, queryId) {
-        const connectionDefer = new Deferred();
-        const connectionReleaseDefer = new Deferred();
-        this.provideConnection(async (connection) => {
-            connectionDefer.resolve(connection);
-            // Lets wait until we don't need connection before returning here (returning releases connection)
-            return await connectionReleaseDefer.promise;
-        }).catch((ex) => connectionDefer.reject(ex));
-        const connection = await connectionDefer.promise;
+        const { connection, release } = await provideControlledConnection(this);
         try {
             for await (const result of connection.streamQuery(compiledQuery, chunkSize)) {
                 yield await this.#transformResult(result, queryId);
             }
         }
         finally {
-            connectionReleaseDefer.resolve();
+            release();
         }
     }
     async #transformResult(result, queryId) {
@@ -64,14 +57,3 @@ export class QueryExecutorBase {
         return result;
     }
 }
-// TODO: remove.
-function warnOfOutdatedDriverOrPlugins(result, transformedResult) {
-    const { numAffectedRows } = result;
-    if ((numAffectedRows === undefined &&
-        result.numUpdatedOrDeletedRows === undefined) ||
-        (numAffectedRows !== undefined &&
-            transformedResult.numAffectedRows !== undefined)) {
-        return;
-    }
-    logOnce('kysely:warning: outdated driver/plugin detected! QueryResult.numUpdatedOrDeletedRows is deprecated and will be removed in a future release.');
-}

package/dist/esm/raw-builder/raw-builder.js

@@ -1,6 +1,5 @@
 /// <reference types="./raw-builder.d.ts" />
 import { AliasNode } from '../operation-node/alias-node.js';
-import { preventAwait } from '../util/prevent-await.js';
 import { freeze } from '../util/object-utils.js';
 import { NOOP_QUERY_EXECUTOR } from '../query-executor/noop-query-executor.js';
 import { IdentifierNode } from '../operation-node/identifier-node.js';
@@ -61,7 +60,6 @@ class RawBuilderImpl {
 export function createRawBuilder(props) {
     return new RawBuilderImpl(props);
 }
-preventAwait(RawBuilderImpl, "don't await RawBuilder instances directly. To execute the query you need to call `execute`");
 class AliasedRawBuilderImpl {
     #rawBuilder;
     #alias;
@@ -84,4 +82,3 @@ class AliasedRawBuilderImpl {
             : IdentifierNode.create(this.#alias));
     }
 }
-preventAwait(AliasedRawBuilderImpl, "don't await AliasedRawBuilder instances directly. AliasedRawBuilder should never be executed directly since it's always a part of another query.");

package/dist/esm/raw-builder/sql.d.ts

@@ -213,7 +213,7 @@ export interface Sql {
      * select first_name from "public"."person"
      * ```
      */
-    table(tableReference: string): RawBuilder<unknown>;
+    table<T = unknown>(tableReference: string): RawBuilder<T>;
     /**
      * This can be used to add arbitrary identifiers to SQL snippets.
      *
@@ -255,7 +255,7 @@ export interface Sql {
      * select "public"."person"."first_name" from "public"."person"
      * ```
      */
-    id(...ids: readonly string[]): RawBuilder<unknown>;
+    id<T = unknown>(...ids: readonly string[]): RawBuilder<T>;
     /**
      * This can be used to add literal values to SQL snippets.
      *
@@ -361,6 +361,6 @@ export interface Sql {
      * BEFORE $1::varchar, (1 == 1)::varchar, (select * from "person")::varchar, false::varchar, "first_name" AFTER
      * ```
      */
-    join(array: readonly unknown[], separator?: RawBuilder<any>): RawBuilder<unknown>;
+    join<T = unknown>(array: readonly unknown[], separator?: RawBuilder<any>): RawBuilder<T>;
 }
 export declare const sql: Sql;

package/dist/esm/raw-builder/sql.js

@@ -60,7 +60,7 @@ export const sql = Object.assign((sqlFragments, ...parameters) => {
         });
     },
     join(array, separator = sql `, `) {
-        const nodes = new Array(2 * array.length - 1);
+        const nodes = new Array(Math.max(2 * array.length - 1, 0));
         const sep = separator.toOperationNode();
         for (let i = 0; i < array.length; ++i) {
             nodes[2 * i] = parseParameter(array[i]);

package/dist/esm/schema/alter-column-builder.js

@@ -2,7 +2,6 @@
 import { AlterColumnNode } from '../operation-node/alter-column-node.js';
 import { parseDataTypeExpression, } from '../parser/data-type-parser.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
-import { preventAwait } from '../util/prevent-await.js';
 export class AlterColumnBuilder {
     #column;
     constructor(column) {
@@ -31,7 +30,6 @@ export class AlterColumnBuilder {
         return func(this);
     }
 }
-preventAwait(AlterColumnBuilder, "don't await AlterColumnBuilder instances");
 /**
  * Allows us to force consumers to do exactly one alteration to a column.
  *
@@ -70,4 +68,3 @@ export class AlteredColumnBuilder {
         return this.#alterColumnNode;
     }
 }
-preventAwait(AlteredColumnBuilder, "don't await AlteredColumnBuilder instances");

package/dist/esm/schema/alter-table-add-foreign-key-constraint-builder.d.ts

@@ -11,6 +11,10 @@ export declare class AlterTableAddForeignKeyConstraintBuilder implements Foreign
     constructor(props: AlterTableAddForeignKeyConstraintBuilderProps);
     onDelete(onDelete: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
     onUpdate(onUpdate: OnModifyForeignAction): AlterTableAddForeignKeyConstraintBuilder;
+    deferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    notDeferrable(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyDeferred(): AlterTableAddForeignKeyConstraintBuilder;
+    initiallyImmediate(): AlterTableAddForeignKeyConstraintBuilder;
     /**
      * Simply calls the provided function passing `this` as the only argument. `$call` returns
      * what the provided function returns.