kysely 0.24.2 → 0.26.0

package/dist/cjs/schema/create-index-builder.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateIndexBuilder = void 0;
 const create_index_node_js_1 = require("../operation-node/create-index-node.js");
-const list_node_js_1 = require("../operation-node/list-node.js");
 const raw_node_js_1 = require("../operation-node/raw-node.js");
 const reference_parser_js_1 = require("../parser/reference-parser.js");
 const table_parser_js_1 = require("../parser/table-parser.js");
@@ -52,29 +51,62 @@ class CreateIndexBuilder {
         });
     }
     /**
-     * Specifies the column for the index.
+     * Adds a column to the index.
      *
-     * Also see the `expression` for specifying an arbitrary expression.
+     * Also see {@link columns} for adding multiple columns at once or {@link expression}
+     * for specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .createIndex('person_first_name_and_age_index')
+     *         .on('person')
+     *         .column('first_name')
+     *         .column('age desc')
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+     * ```
      */
     column(column) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: create_index_node_js_1.CreateIndexNode.cloneWith(this.#props.node, {
-                expression: (0, reference_parser_js_1.parseColumnName)(column),
-            }),
+            node: create_index_node_js_1.CreateIndexNode.cloneWithColumns(this.#props.node, [
+                (0, reference_parser_js_1.parseOrderedColumnName)(column),
+            ]),
         });
     }
     /**
      * Specifies a list of columns for the index.
      *
-     * Also see the `expression` for specifying an arbitrary expression.
+     * Also see {@link column} for adding a single column or {@link expression} for
+     * specifying an arbitrary expression.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *         .createIndex('person_first_name_and_age_index')
+     *         .on('person')
+     *         .columns(['first_name', 'age desc'])
+     *         .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_and_age_index" on "person" ("first_name", "age" desc)
+     * ```
      */
     columns(columns) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: create_index_node_js_1.CreateIndexNode.cloneWith(this.#props.node, {
-                expression: list_node_js_1.ListNode.create(columns.map(reference_parser_js_1.parseColumnName)),
-            }),
+            node: create_index_node_js_1.CreateIndexNode.cloneWithColumns(this.#props.node, columns.map(reference_parser_js_1.parseOrderedColumnName)),
         });
     }
     /**
@@ -91,13 +123,19 @@ class CreateIndexBuilder {
      *   .expression(sql`first_name COLLATE "fi_FI"`)
      *   .execute()
      * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * create index "person_first_name_index" on "person" (first_name COLLATE "fi_FI")
+     * ```
      */
     expression(expression) {
         return new CreateIndexBuilder({
             ...this.#props,
-            node: create_index_node_js_1.CreateIndexNode.cloneWith(this.#props.node, {
-                expression: expression.toOperationNode(),
-            }),
+            node: create_index_node_js_1.CreateIndexNode.cloneWithColumns(this.#props.node, [
+                expression.toOperationNode(),
+            ]),
         });
     }
     using(indexType) {
@@ -112,7 +150,7 @@ class CreateIndexBuilder {
         const transformer = new immediate_value_transformer_js_1.ImmediateValueTransformer();
         return new CreateIndexBuilder({
             ...this.#props,
-            node: query_node_js_1.QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode((0, binary_operation_parser_js_1.parseWhere)(args))),
+            node: query_node_js_1.QueryNode.cloneWithWhere(this.#props.node, transformer.transformNode((0, binary_operation_parser_js_1.parseFilter)(args))),
         });
     }
     /**

package/dist/cjs/schema/create-table-builder.d.ts

@@ -238,10 +238,6 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```
      */
     $call<T>(func: (qb: this) => T): T;
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call<T>(func: (qb: this) => T): T;
     toOperationNode(): CreateTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
@@ -251,5 +247,5 @@ export interface CreateTableBuilderProps {
     readonly executor: QueryExecutor;
     readonly node: CreateTableNode;
 }
-export declare type ColumnBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
-export declare type ForeignKeyConstraintBuilderCallback = (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder;
+export type ColumnBuilderCallback = (builder: ColumnDefinitionBuilder) => ColumnDefinitionBuilder;
+export type ForeignKeyConstraintBuilderCallback = (builder: ForeignKeyConstraintBuilder) => ForeignKeyConstraintBuilder;

package/dist/cjs/schema/create-table-builder.js

@@ -307,12 +307,6 @@ class CreateTableBuilder {
     $call(func) {
         return func(this);
     }
-    /**
-     * @deprecated Use `$call` instead
-     */
-    call(func) {
-        return this.$call(func);
-    }
     toOperationNode() {
         return this.#props.executor.transformQuery(this.#props.node, this.#props.queryId);
     }

package/dist/cjs/schema/schema.d.ts

@@ -139,8 +139,7 @@ export declare class SchemaModule {
      * ```ts
      * await db.schema
      *   .alterTable('person')
-     *   .alterColumn('first_name')
-     *   .setDataType('text')
+     *   .alterColumn('first_name', (ac) => ac.setDataType('text'))
      *   .execute()
      * ```
      */

package/dist/cjs/schema/schema.js

@@ -193,8 +193,7 @@ class SchemaModule {
      * ```ts
      * await db.schema
      *   .alterTable('person')
-     *   .alterColumn('first_name')
-     *   .setDataType('text')
+     *   .alterColumn('first_name', (ac) => ac.setDataType('text'))
      *   .execute()
      * ```
      */
@@ -202,7 +201,7 @@ class SchemaModule {
         return new alter_table_builder_js_1.AlterTableBuilder({
             queryId: (0, query_id_js_1.createQueryId)(),
             executor: this.#executor,
-            node: alter_table_node_js_1.AlterTableNode.create(table),
+            node: alter_table_node_js_1.AlterTableNode.create((0, table_parser_js_1.parseTable)(table)),
         });
     }
     /**

package/dist/cjs/util/column-type.d.ts

@@ -33,7 +33,7 @@
  * ColumnType<Date, string, never>
  * ```
  */
-export declare type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectType> = {
+export type ColumnType<SelectType, InsertType = SelectType, UpdateType = SelectType> = {
     readonly __select__: SelectType;
     readonly __insert__: InsertType;
     readonly __update__: UpdateType;
@@ -51,50 +51,55 @@ export declare type ColumnType<SelectType, InsertType = SelectType, UpdateType =
  * type Generated<S> = ColumnType<S, S | undefined, S>
  * ```
  */
-export declare type Generated<S> = ColumnType<S, S | undefined, S>;
+export type Generated<S> = ColumnType<S, S | undefined, S>;
 /**
  * A shortcut for defining columns that are only database-generated
  * (like postgres GENERATED ALWAYS AS IDENTITY). No insert/update
  * is allowed.
  */
-export declare type GeneratedAlways<S> = ColumnType<S, never, never>;
+export type GeneratedAlways<S> = ColumnType<S, never, never>;
+/**
+ * A shortcut for defining JSON columns, which are by default inserted/updated
+ * as stringified JSON strings.
+ */
+export type JSONColumnType<SelectType extends object | null, InsertType = string, UpdateType = string> = ColumnType<SelectType, InsertType, UpdateType>;
 /**
  * Evaluates to `K` if `T` can be `null` or `undefined`.
  */
-declare type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
+type IfNullable<T, K> = undefined extends T ? K : null extends T ? K : never;
 /**
  * Evaluates to `K` if `T` can't be `null` or `undefined`.
  */
-declare type IfNotNullable<T, K> = undefined extends T ? never : null extends T ? never : T extends never ? never : K;
+type IfNotNullable<T, K> = undefined extends T ? never : null extends T ? never : T extends never ? never : K;
 /**
  * Evaluates to `K` if `T` isn't `never`.
  */
-declare type IfNotNever<T, K> = T extends never ? never : K;
-export declare type SelectType<T> = T extends ColumnType<infer S, any, any> ? S : T;
-export declare type InsertType<T> = T extends ColumnType<any, infer I, any> ? I : T;
-export declare type UpdateType<T> = T extends ColumnType<any, any, infer U> ? U : T;
+type IfNotNever<T, K> = T extends never ? never : K;
+export type SelectType<T> = T extends ColumnType<infer S, any, any> ? S : T;
+export type InsertType<T> = T extends ColumnType<any, infer I, any> ? I : T;
+export type UpdateType<T> = T extends ColumnType<any, any, infer U> ? U : T;
 /**
  * Keys of `R` whose `InsertType` values can be `null` or `undefined`.
  */
-export declare type NullableInsertKeys<R> = {
+export type NullableInsertKeys<R> = {
     [K in keyof R]: IfNullable<InsertType<R[K]>, K>;
 }[keyof R];
 /**
  * Keys of `R` whose `InsertType` values can't be `null` or `undefined`.
  */
-export declare type NonNullableInsertKeys<R> = {
+export type NonNullableInsertKeys<R> = {
     [K in keyof R]: IfNotNullable<InsertType<R[K]>, K>;
 }[keyof R];
 /**
  * Keys of `R` whose `SelectType` values are not `never`
  */
-declare type NonNeverSelectKeys<R> = {
+type NonNeverSelectKeys<R> = {
     [K in keyof R]: IfNotNever<SelectType<R[K]>, K>;
 }[keyof R];
 /**
  * Keys of `R` whose `UpdateType` values are not `never`
  */
-export declare type UpdateKeys<R> = {
+export type UpdateKeys<R> = {
     [K in keyof R]: IfNotNever<UpdateType<R[K]>, K>;
 }[keyof R];
 /**
@@ -118,7 +123,7 @@ export declare type UpdateKeys<R> = {
  * // }
  * ```
  */
-export declare type Selectable<R> = {
+export type Selectable<R> = {
     [K in NonNeverSelectKeys<R>]: SelectType<R[K]>;
 };
 /**
@@ -142,7 +147,7 @@ export declare type Selectable<R> = {
  * // }
  * ```
  */
-export declare type Insertable<R> = {
+export type Insertable<R> = {
     [K in NonNullableInsertKeys<R>]: InsertType<R[K]>;
 } & {
     [K in NullableInsertKeys<R>]?: InsertType<R[K]>;
@@ -167,7 +172,7 @@ export declare type Insertable<R> = {
  * // }
  * ```
  */
-export declare type Updateable<R> = {
+export type Updateable<R> = {
     [K in UpdateKeys<R>]?: UpdateType<R[K]>;
 };
 export {};

package/dist/cjs/util/explainable.d.ts

@@ -1,5 +1,5 @@
 import { Expression } from '../expression/expression.js';
-export declare type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
+export type ExplainFormat = 'text' | 'xml' | 'json' | 'yaml' | 'traditional' | 'tree';
 export interface Explainable {
     /**
      * Executes query with `explain` statement before the main query.

package/dist/cjs/util/infer-result.d.ts

@@ -41,6 +41,6 @@ import { Compilable } from './compilable.js';
  * type QueryResult = InferResult<typeof compiledQuery> // Selectable<Person>[]
  * ```
  */
-export declare type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
-declare type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult ? O : O[];
+export type InferResult<C extends Compilable<any> | CompiledQuery<any>> = C extends Compilable<infer O> ? ResolveResult<O> : C extends CompiledQuery<infer O> ? ResolveResult<O> : never;
+type ResolveResult<O> = O extends InsertResult | UpdateResult | DeleteResult ? O : O[];
 export {};

package/dist/cjs/util/log.d.ts

@@ -1,7 +1,7 @@
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { ArrayItemType } from './type-utils.js';
 export declare const LOG_LEVELS: readonly ["query", "error"];
-export declare type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
+export type LogLevel = ArrayItemType<typeof LOG_LEVELS>;
 export interface QueryLogEvent {
     readonly level: 'query';
     readonly query: CompiledQuery;
@@ -13,13 +13,13 @@ export interface ErrorLogEvent {
     readonly query: CompiledQuery;
     readonly queryDurationMillis: number;
 }
-export declare type LogEvent = QueryLogEvent | ErrorLogEvent;
-export declare type Logger = (event: LogEvent) => void;
-export declare type LogConfig = ReadonlyArray<LogLevel> | Logger;
+export type LogEvent = QueryLogEvent | ErrorLogEvent;
+export type Logger = (event: LogEvent) => void | Promise<void>;
+export type LogConfig = ReadonlyArray<LogLevel> | Logger;
 export declare class Log {
     #private;
     constructor(config: LogConfig);
     isLevelEnabled(level: LogLevel): boolean;
-    query(getEvent: () => QueryLogEvent): void;
-    error(getEvent: () => ErrorLogEvent): void;
+    query(getEvent: () => QueryLogEvent): Promise<void>;
+    error(getEvent: () => ErrorLogEvent): Promise<void>;
 }

package/dist/cjs/util/log.js

@@ -25,14 +25,14 @@ class Log {
     isLevelEnabled(level) {
         return this.#levels[level];
     }
-    query(getEvent) {
+    async query(getEvent) {
         if (this.#levels.query) {
-            this.#logger(getEvent());
+            await this.#logger(getEvent());
         }
     }
-    error(getEvent) {
+    async error(getEvent) {
         if (this.#levels.error) {
-            this.#logger(getEvent());
+            await this.#logger(getEvent());
         }
     }
 }

package/dist/cjs/util/object-utils.d.ts

@@ -1,3 +1,4 @@
+import { ShallowRecord } from './type-utils.js';
 export declare function isEmpty(obj: ArrayLike<unknown> | string | object): boolean;
 export declare function isUndefined(obj: unknown): obj is undefined;
 export declare function isString(obj: unknown): obj is string;
@@ -10,7 +11,7 @@ export declare function isBuffer(obj: unknown): obj is {
     length: number;
 };
 export declare function isFunction(obj: unknown): obj is Function;
-export declare function isObject(obj: unknown): obj is Record<string, unknown>;
+export declare function isObject(obj: unknown): obj is ShallowRecord<string, unknown>;
 export declare function isArrayBufferOrView(obj: unknown): obj is ArrayBuffer | ArrayBufferView;
 export declare function getLast<T>(arr: ArrayLike<T>): T | undefined;
 export declare function freeze<T>(obj: T): Readonly<T>;

package/dist/cjs/util/require-all-props.d.ts

@@ -3,7 +3,7 @@
  *
  * Similar to Required<T> build-in type, but allows `undefined` values.
  */
-declare type AllProps<T> = T & {
+type AllProps<T> = T & {
     [P in keyof T]-?: unknown;
 };
 /**

package/dist/cjs/util/type-utils.d.ts

@@ -2,10 +2,7 @@ import { SelectQueryBuilder } from '../query-builder/select-query-builder.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';
-/**
- * Given an object type, extracts the union of all value types.
- */
-export declare type ValueType<T> = T[keyof T];
+import { KyselyTypeError } from './type-error.js';
 /**
  * Given a database type and a union of table names in that db, returns
  * a union type with all possible column names.
@@ -37,13 +34,13 @@ export declare type ValueType<T> = T[keyof T];
  * // Columns == 'id' | 'name' | 'species'
  * ```
  */
-export declare type AnyColumn<DB, TB extends keyof DB> = {
+export type AnyColumn<DB, TB extends keyof DB> = DrainOuterGeneric<{
     [T in TB]: keyof DB[T];
-}[TB] & string;
+}[TB] & string>;
 /**
  * Extracts a column type.
  */
-export declare type ExtractColumnType<DB, TB extends keyof DB, C> = {
+export type ExtractColumnType<DB, TB extends keyof DB, C> = {
     [T in TB]: C extends keyof DB[T] ? DB[T][C] : never;
 }[TB];
 /**
@@ -77,71 +74,88 @@ export declare type ExtractColumnType<DB, TB extends keyof DB, C> = {
  * // Columns == 'person.id' | 'pet.name' | 'pet.species'
  * ```
  */
-export declare type AnyColumnWithTable<DB, TB extends keyof DB> = {
+export type AnyColumnWithTable<DB, TB extends keyof DB> = {
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${T}.${keyof DB[T]}` : never : never;
 }[TB];
 /**
  * Just like {@link AnyColumn} but with a ` as <string>` suffix.
  */
-export declare type AnyAliasedColumn<DB, TB extends keyof DB> = {
+export type AnyAliasedColumn<DB, TB extends keyof DB> = {
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${keyof DB[T]} as ${string}` : never : never;
 }[TB];
 /**
  * Just like {@link AnyColumnWithTable} but with a ` as <string>` suffix.
  */
-export declare type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
+export type AnyAliasedColumnWithTable<DB, TB extends keyof DB> = {
     [T in TB]: T extends string ? keyof DB[T] extends string ? `${T}.${keyof DB[T]} as ${string}` : never : never;
 }[TB];
 /**
  * Extracts the item type of an array.
  */
-export declare type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
+export type ArrayItemType<T> = T extends ReadonlyArray<infer I> ? I : never;
 /**
  * Any select query builder.
  */
-export declare type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
-export declare type SimplifySingleResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O> | undefined;
-export declare type SimplifyResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O>;
-export declare type Simplify<T> = {
+export type AnySelectQueryBuilder = SelectQueryBuilder<any, any, any>;
+export type SimplifySingleResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O> | undefined;
+export type SimplifyResult<O> = O extends InsertResult ? O : O extends DeleteResult ? O : O extends UpdateResult ? O : Simplify<O>;
+export type Simplify<T> = DrainOuterGeneric<{
     [K in keyof T]: T[K];
-} & {};
+} & {}>;
 /**
  * Represents a database row whose column names and their types are unknown.
  */
-export declare type UnknownRow = Record<string, unknown>;
+export type UnknownRow = Record<string, unknown>;
 /**
  * Makes all properties of object type `T` nullable.
  */
-export declare type Nullable<T> = {
+export type Nullable<T> = {
     [P in keyof T]: T[P] | null;
 };
 /**
- * Takes all properties from T1 and merges all properties from T2
- * that don't exist in T1 as optional properties.
+ * Evaluates to `true` if `T` is `never`.
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Evaluates to `true` if `T` is `any`.
+ */
+export type IsAny<T> = 0 extends T & 1 ? true : false;
+/**
+ * Evaluates to `true` if the types `T` and `U` are equal.
+ */
+export type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
+export type NarrowPartial<S, T> = DrainOuterGeneric<{
+    [K in keyof S & string]: K extends keyof T ? T[K] extends S[K] ? T[K] : KyselyTypeError<`$narrowType() call failed: passed type does not exist in '${K}'s type union`> : S[K];
+}>;
+export type SqlBool = boolean | 0 | 1;
+/**
+ * Utility to reduce depth of TypeScript's internal type instantiation stack.
  *
  * Example:
  *
- * interface Person {
- *   name: string
- *   age: number
- * }
+ * ```ts
+ * type A<T> = { item: T }
  *
- * interface Pet {
- *   name: string
- *   species: 'cat' | 'dog'
- * }
+ * type Test<T> = A<
+ *   A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
  *
- * type Merged = MergePartial<Person, Pet>
+ * type Error = Test<number> // Type instantiation is excessively deep and possibly infinite.ts (2589)
+ * ```
  *
- * // { name: string, age: number, species?: 'cat' | 'dog' }
- */
-export declare type MergePartial<T1, T2> = T1 & Partial<Omit<T2, keyof T1>>;
-/**
- * Evaluates to `true` if `T` is `never`.
- */
-export declare type IsNever<T> = [T] extends [never] ? true : false;
-/**
- * Evaluates to `true` if the types `T` and `U` are equal.
+ * To fix this, we can use `DrainOuterGeneric`:
+ *
+ * ```ts
+ * type A<T> = DrainOuterGeneric<{ item: T }>
+ *
+ * type Test<T> = A<
+ *  A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<A<T>>>>>>>>>>>>>>>>>>>>>>>>
+ * >
+ *
+ * type Ok = Test<number> // Ok
+ * ```
  */
-export declare type Equals<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;
-export declare type SqlBool = boolean | 0 | 1;
+export type DrainOuterGeneric<T> = [T] extends [unknown] ? T : never;
+export type ShallowRecord<K extends keyof any, T> = DrainOuterGeneric<{
+    [P in K]: T;
+}>;

package/dist/esm/dialect/database-introspector.d.ts

@@ -30,7 +30,7 @@ export interface SchemaMetadata {
 export interface DatabaseMetadata {
     /**
      * The tables and views found in the database.
-  *  * The propery isView can be used to tell them apart.
+     * The propery isView can be used to tell them apart.
      */
     readonly tables: TableMetadata[];
 }

package/dist/esm/dialect/mysql/mysql-dialect-config.d.ts

@@ -46,6 +46,7 @@ export interface MysqlStream<T> {
 }
 export interface MysqlOkPacket {
     affectedRows: number;
+    changedRows: number;
     insertId: number;
 }
-export declare type MysqlQueryResult = MysqlOkPacket | Record<string, unknown>[];
+export type MysqlQueryResult = MysqlOkPacket | Record<string, unknown>[];

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

@@ -83,10 +83,13 @@ class MysqlConnection {
         try {
             const result = await this.#executeQuery(compiledQuery);
             if (isOkPacket(result)) {
-                const { insertId, affectedRows } = result;
+                const { insertId, affectedRows, changedRows } = result;
                 const numAffectedRows = affectedRows !== undefined && affectedRows !== null
                     ? BigInt(affectedRows)
                     : undefined;
+                const numChangedRows = changedRows !== undefined && changedRows !== null
+                    ? BigInt(changedRows)
+                    : undefined;
                 return {
                     insertId: insertId !== undefined &&
                         insertId !== null &&
@@ -96,6 +99,7 @@ class MysqlConnection {
                     // TODO: remove.
                     numUpdatedOrDeletedRows: numAffectedRows,
                     numAffectedRows,
+                    numChangedRows,
                     rows: [],
                 };
             }

package/dist/esm/dialect/postgres/postgres-dialect-config.d.ts

@@ -50,7 +50,7 @@ export interface PostgresCursor<T> {
     read(rowsCount: number): Promise<T[]>;
     close(): Promise<void>;
 }
-export declare type PostgresCursorConstructor = new <T>(sql: string, parameters: unknown[]) => PostgresCursor<T>;
+export type PostgresCursorConstructor = new <T>(sql: string, parameters: unknown[]) => PostgresCursor<T>;
 export interface PostgresQueryResult<R> {
     command: 'UPDATE' | 'DELETE' | 'INSERT' | 'SELECT';
     rowCount: number;

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

@@ -48,7 +48,7 @@ export class PostgresIntrospector {
                 .as('auto_incrementing'),
         ])
             // r == normal table
-            .where('c.relkind', 'in', ['r', 'v'])
+            .where((eb) => eb.or([eb('c.relkind', '=', 'r'), eb('c.relkind', '=', 'v')]))
             .where('ns.nspname', '!~', '^pg_')
             .where('ns.nspname', '!=', 'information_schema')
             // No system columns

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

@@ -12,7 +12,7 @@ export class SqliteIntrospector {
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
-            .selectFrom('sqlite_schema')
+            .selectFrom('sqlite_master')
             .where('type', 'in', ['table', 'view'])
             .where('name', 'not like', 'sqlite_%')
             .select('name')

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

@@ -18,6 +18,12 @@ export interface QueryResult<O> {
      * the number of rows the query inserted/updated/deleted.
      */
     readonly numAffectedRows?: bigint;
+    /**
+     * This is defined for update queries and contains the number of rows
+     * the query changed.
+     * This is optional and only provided by some drivers like node-mysql2.
+     */
+    readonly numChangedRows?: bigint;
     /**
      * This is defined for insert queries on dialects that return
      * the auto incrementing primary key from an insert.

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

@@ -41,4 +41,4 @@ export interface TransactionSettings {
     readonly isolationLevel?: IsolationLevel;
 }
 export declare const TRANSACTION_ISOLATION_LEVELS: readonly ["read uncommitted", "read committed", "repeatable read", "serializable"];
-export declare type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;
+export type IsolationLevel = ArrayItemType<typeof TRANSACTION_ISOLATION_LEVELS>;

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

@@ -74,24 +74,24 @@ export class RuntimeDriver {
                 return await executeQuery.call(connection, compiledQuery);
             }
             catch (error) {
-                this.#logError(error, compiledQuery, startTime);
+                await this.#logError(error, compiledQuery, startTime);
                 throw error;
             }
             finally {
-                this.#logQuery(compiledQuery, startTime);
+                await this.#logQuery(compiledQuery, startTime);
             }
         };
     }
-    #logError(error, compiledQuery, startTime) {
-        this.#log.error(() => ({
+    async #logError(error, compiledQuery, startTime) {
+        await this.#log.error(() => ({
             level: 'error',
             error,
             query: compiledQuery,
             queryDurationMillis: this.#calculateDurationMillis(startTime),
         }));
     }
-    #logQuery(compiledQuery, startTime) {
-        this.#log.query(() => ({
+    async #logQuery(compiledQuery, startTime) {
+        await this.#log.query(() => ({
             level: 'query',
             query: compiledQuery,
             queryDurationMillis: this.#calculateDurationMillis(startTime),