kysely 0.30.0-beta.0 → 0.30.0-beta.2

package/README.md

@@ -1,7 +1,7 @@
 [![Stand With Ukraine](https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-direct.svg)](https://stand-with-ukraine.pp.ua)
 
 [![NPM Version](https://img.shields.io/npm/v/kysely?style=flat&label=latest)](https://github.com/kysely-org/kysely/releases/latest)
-[![Socket Badge](https://badge.socket.dev/npm/package/kysely/0.30.0-beta.0)](https://socket.dev/npm/package/kysely/overview/0.30.0-beta.0)
+[![Socket Badge](https://badge.socket.dev/npm/package/kysely/0.30.0-beta.2)](https://socket.dev/npm/package/kysely/overview/0.30.0-beta.2)
 [![Tests](https://github.com/kysely-org/kysely/actions/workflows/test.yml/badge.svg)](https://github.com/kysely-org/kysely)
 [![License](https://img.shields.io/github/license/kysely-org/kysely?style=flat)](https://github.com/kysely-org/kysely/blob/master/LICENSE)
 [![Issues](https://img.shields.io/github/issues-closed/kysely-org/kysely?logo=github)](https://github.com/kysely-org/kysely/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc)

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

@@ -1,3 +1,5 @@
+import type { Expression } from '../expression/expression.js';
+import type { SqlBool } from '../util/type-utils.js';
 /**
  * An interface for getting the database metadata (names of the tables and columns etc.)
  */
@@ -5,27 +7,59 @@ export interface DatabaseIntrospector {
     /**
      * Get schema metadata.
      */
-    getSchemas(): Promise<SchemaMetadata[]>;
+    getSchemas(options?: DatabaseSchemaMetadataOptions): Promise<SchemaMetadata[]>;
     /**
      * Get tables and views metadata.
      */
     getTables(options?: DatabaseMetadataOptions): Promise<TableMetadata[]>;
 }
+export interface DatabaseSchemaMetadataOptions {
+    /**
+     * An optional SQL `where` expression for filtering the schemas returned by
+     * the introspector.
+     *
+     * The refs argument contains an SQL reference to the schema name column
+     * within the catalog query this expression will be used in.
+     */
+    where?: (refs: Readonly<{
+        schema: Expression<string>;
+    }>) => Expression<SqlBool>;
+}
 export interface DatabaseMetadataOptions {
+    /**
+     * An optional SQL `where` expression for filtering the tables returned by
+     * the introspector.
+     *
+     * The refs argument contains SQL references to the table name and optional
+     * schema name columns within the catalog query this expression will be used
+     * in.
+     */
+    where?: (refs: Readonly<{
+        table: Expression<string>;
+        schema?: Expression<string>;
+    }>) => Expression<SqlBool>;
     /**
      * If this is true, the metadata contains the internal kysely tables
      * such as the migration tables.
      */
     withInternalKyselyTables: boolean;
+    /**
+     * If this is true, tables from non-default databases are also returned.
+     *
+     * This option only affects MySQL and defaults to false. System databases are
+     * excluded regardless of this option.
+     */
+    withNonDefaultDatabases?: boolean;
 }
 export interface SchemaMetadata {
     readonly name: string;
 }
 export interface TableMetadata {
-    readonly name: string;
-    readonly isView: boolean;
-    readonly isForeign: boolean;
     readonly columns: ColumnMetadata[];
+    readonly comment?: string;
+    readonly isForeign: boolean;
+    readonly isView: boolean;
+    readonly name: string;
     readonly schema?: string;
 }
 export interface ColumnMetadata {

package/dist/dialect/mssql/mssql-introspector.d.ts

@@ -1,12 +1,12 @@
 import type { Kysely } from '../../kysely.js';
-import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, DatabaseSchemaMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 export declare class MssqlIntrospector implements DatabaseIntrospector {
     #private;
     constructor(db: Kysely<any>);
     /**
      * Get schema metadata.
      */
-    getSchemas(): Promise<SchemaMetadata[]>;
+    getSchemas(options?: DatabaseSchemaMetadataOptions): Promise<SchemaMetadata[]>;
     /**
      * Get tables and views metadata.
      */

package/dist/dialect/mssql/mssql-introspector.js

@@ -1,15 +1,28 @@
 /// <reference types="./mssql-introspector.d.ts" />
 import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
+import { sql } from '../../raw-builder/sql.js';
 import { freeze } from '../../util/object-utils.js';
 export class MssqlIntrospector {
     #db;
     constructor(db) {
         this.#db = db;
     }
-    async getSchemas() {
-        return await this.#db.selectFrom('sys.schemas').select('name').execute();
+    async getSchemas(options = {}) {
+        let query = this.#db.selectFrom('sys.schemas').select('name');
+        if (options.where) {
+            query = query.where(options.where({ schema: sql.ref('name') }));
+        }
+        return await query.execute();
     }
     async getTables(options = { withInternalKyselyTables: false }) {
+        const tablesWhere = options.where?.({
+            schema: sql.ref('table_schemas.name'),
+            table: sql.ref('tables.name'),
+        });
+        const viewsWhere = options.where?.({
+            schema: sql.ref('view_schemas.name'),
+            table: sql.ref('views.name'),
+        });
         const rawColumns = await this.#db
             .selectFrom('sys.tables as tables')
             .leftJoin('sys.schemas as table_schemas', 'table_schemas.schema_id', 'tables.schema_id')
@@ -17,12 +30,19 @@ export class MssqlIntrospector {
             .innerJoin('sys.types as types', 'types.user_type_id', 'columns.user_type_id')
             .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
             .leftJoin('sys.extended_properties as comments', (join) => join
+            .on('comments.class', '=', 1)
             .onRef('comments.major_id', '=', 'tables.object_id')
             .onRef('comments.minor_id', '=', 'columns.column_id')
             .on('comments.name', '=', 'MS_Description'))
+            .leftJoin('sys.extended_properties as table_comments', (join) => join
+            .on('table_comments.class', '=', 1)
+            .onRef('table_comments.major_id', '=', 'tables.object_id')
+            .on('table_comments.minor_id', '=', 0)
+            .on('table_comments.name', '=', 'MS_Description'))
             .$if(!options.withInternalKyselyTables, (qb) => qb
             .where('tables.name', '!=', DEFAULT_MIGRATION_TABLE)
             .where('tables.name', '!=', DEFAULT_MIGRATION_LOCK_TABLE))
+            .$if(!!tablesWhere, (qb) => qb.where(tablesWhere))
             .select([
             'tables.name as table_name',
             (eb) => eb
@@ -41,6 +61,7 @@ export class MssqlIntrospector {
             'types.name as type_name',
             'type_schemas.name as type_schema_name',
             'comments.value as column_comment',
+            'table_comments.value as table_comment',
         ])
             .unionAll(this.#db
             .selectFrom('sys.views as views')
@@ -49,9 +70,16 @@ export class MssqlIntrospector {
             .innerJoin('sys.types as types', 'types.user_type_id', 'columns.user_type_id')
             .leftJoin('sys.schemas as type_schemas', 'type_schemas.schema_id', 'types.schema_id')
             .leftJoin('sys.extended_properties as comments', (join) => join
+            .on('comments.class', '=', 1)
             .onRef('comments.major_id', '=', 'views.object_id')
             .onRef('comments.minor_id', '=', 'columns.column_id')
             .on('comments.name', '=', 'MS_Description'))
+            .leftJoin('sys.extended_properties as table_comments', (join) => join
+            .on('table_comments.class', '=', 1)
+            .onRef('table_comments.major_id', '=', 'views.object_id')
+            .on('table_comments.minor_id', '=', 0)
+            .on('table_comments.name', '=', 'MS_Description'))
+            .$if(!!viewsWhere, (qb) => qb.where(viewsWhere))
             .select([
             'views.name as table_name',
             'views.type as table_type',
@@ -67,6 +95,7 @@ export class MssqlIntrospector {
             'types.name as type_name',
             'type_schemas.name as type_schema_name',
             'comments.value as column_comment',
+            'table_comments.value as table_comment',
         ]))
             .orderBy('table_schema_name')
             .orderBy('table_name')
@@ -79,6 +108,7 @@ export class MssqlIntrospector {
                 tableDictionary[key] ||
                     freeze({
                         columns: [],
+                        comment: rawColumn.table_comment ?? undefined,
                         isForeign: false,
                         isView: rawColumn.table_type === 'V ',
                         name: rawColumn.table_name,

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

@@ -5,23 +5,25 @@ import type { AbortableOperationOptions } from '../../util/abort.js';
  */
 export interface MysqlDialectConfig {
     /**
-     * A `mysql2` `Client` constructor, to be used for connecting to the database
-     * outside of the `pool` to avoid waiting for an idle connection.
+     * A `createConnection` function (from either `mysql2` or `mysql2/promise`),
+     * to be used for connecting to the database outside of the `pool` to avoid
+     * waiting for an idle connection.
      *
      * This is useful for cancelling queries on the database side.
      */
     controlConnection?: {
-        (connectionUri: string): MysqlConnection;
-        (config: object): MysqlConnection;
+        (connectionUri: string): MysqlConnection | Promise<MysqlPromiseConnection>;
+        (config: object): MysqlConnection | Promise<MysqlPromiseConnection>;
     };
     /**
-     * A mysql2 Pool instance or a function that returns one.
+     * A mysql2 Pool instance (from either `mysql2` or `mysql2/promise`) or a
+     * function that returns one.
      *
      * If a function is provided, it's called once when the first query is executed.
      *
      * https://github.com/sidorares/node-mysql2#using-connection-pools
      */
-    pool: MysqlPool | ((options?: AbortableOperationOptions) => Promise<MysqlPool>);
+    pool: MysqlPool | MysqlPromisePool | ((options?: AbortableOperationOptions) => Promise<MysqlPool | MysqlPromisePool>);
     /**
      * Called once for each created connection.
      */
@@ -43,6 +45,17 @@ export interface MysqlPool {
     getConnection(callback: (error: unknown, connection: MysqlPoolConnection) => void): void;
     end(callback: (error: unknown) => void): void;
 }
+/**
+ * This interface is the subset of `mysql2/promise`'s `Pool` class that
+ * kysely needs.
+ *
+ * It's a thin promise wrapper around the callback pool, which it exposes
+ * as its `pool` property. The dialect unwraps it and uses the callback
+ * pool directly.
+ */
+export interface MysqlPromisePool {
+    pool: MysqlPool;
+}
 export interface MysqlConnection {
     config: object;
     connect(callback?: (error: unknown) => void): void;
@@ -52,6 +65,18 @@ export interface MysqlConnection {
     };
     threadId: number;
 }
+/**
+ * This interface is the subset of `mysql2/promise`'s `Connection` class that
+ * kysely needs.
+ *
+ * It's a thin promise wrapper around the callback connection. It's already
+ * connected when the `createConnection` promise resolves, so the dialect
+ * uses its promise-based API directly.
+ */
+export interface MysqlPromiseConnection {
+    destroy(): void;
+    query(sql: string, values?: unknown[]): Promise<unknown>;
+}
 export type MysqlConectionConstructor = new (opts?: object) => MysqlConnection;
 export interface MysqlPoolConnection extends MysqlConnection {
     release(): void;

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

@@ -11,7 +11,7 @@ import type { MysqlDialectConfig } from './mysql-dialect-config.js';
  * The constructor takes an instance of {@link MysqlDialectConfig}.
  *
  * ```ts
- * import { createPool } from 'mysql2'
+ * import { createPool } from 'mysql2/promise' // or just 'mysql2' — both work
  *
  * new MysqlDialect({
  *   pool: createPool({
@@ -25,7 +25,7 @@ import type { MysqlDialectConfig } from './mysql-dialect-config.js';
  * can be a function:
  *
  * ```ts
- * import { createPool } from 'mysql2'
+ * import { createPool } from 'mysql2/promise' // or just 'mysql2' — both work
  *
  * new MysqlDialect({
  *   pool: async () => createPool({

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

@@ -9,7 +9,7 @@ import { MysqlAdapter } from './mysql-adapter.js';
  * The constructor takes an instance of {@link MysqlDialectConfig}.
  *
  * ```ts
- * import { createPool } from 'mysql2'
+ * import { createPool } from 'mysql2/promise' // or just 'mysql2' — both work
  *
  * new MysqlDialect({
  *   pool: createPool({
@@ -23,7 +23,7 @@ import { MysqlAdapter } from './mysql-adapter.js';
  * can be a function:
  *
  * ```ts
- * import { createPool } from 'mysql2'
+ * import { createPool } from 'mysql2/promise' // or just 'mysql2' — both work
  *
  * new MysqlDialect({
  *   pool: async () => createPool({

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

@@ -13,9 +13,12 @@ export class MysqlDriver {
         this.#config = freeze({ ...config });
     }
     async init(options) {
-        this.#pool = isFunction(this.#config.pool)
+        const pool = isFunction(this.#config.pool)
             ? await this.#config.pool(options)
             : this.#config.pool;
+        // A `mysql2/promise` pool's `getConnection` ignores the callback we pass
+        // it, hanging any query forever. Unwrap the callback pool it decorates.
+        this.#pool = isPromisePool(pool) ? pool.pool : pool;
     }
     async acquireConnection(options) {
         const rawConnection = await this.#acquireConnection();
@@ -93,6 +96,12 @@ export class MysqlDriver {
         });
     }
 }
+function isPromisePool(pool) {
+    return ('pool' in pool && isObject(pool.pool) && isFunction(pool.pool.getConnection));
+}
+function isPromiseConnection(connection) {
+    return isFunction(connection.then);
+}
 function isOkPacket(obj) {
     return isObject(obj) && 'insertId' in obj && 'affectedRows' in obj;
 }
@@ -224,7 +233,24 @@ class MysqlConnection {
         const { 
         // omitting these as they cause a warning and perhaps a future error when passed.
         clientFlags: _, maxPacketSize: __, ...cfg } = config;
-        const controlConnection = this.#controlConnection(cfg);
+        const controlConnectionOrPromise = this.#controlConnection(cfg);
+        // `mysql2/promise`'s `createConnection` returns a promise of a connection
+        // that's already connected, with a promise-based API. Use it directly.
+        if (isPromiseConnection(controlConnectionOrPromise)) {
+            const controlConnection = await controlConnectionOrPromise;
+            try {
+                // by the time we get the connection, another query might have been executed.
+                // we need to ensure we're not canceling the wrong query.
+                if (queryIdToCancel.queryId === this.#queryId?.queryId) {
+                    await controlConnection.query(query, []);
+                }
+            }
+            finally {
+                controlConnection.destroy();
+            }
+            return;
+        }
+        const controlConnection = controlConnectionOrPromise;
         try {
             await new Promise((resolve, reject) => {
                 controlConnection.connect((connectError) => {

package/dist/dialect/mysql/mysql-introspector.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, DatabaseSchemaMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import type { Kysely } from '../../kysely.js';
 export declare class MysqlIntrospector implements DatabaseIntrospector {
     #private;
@@ -6,7 +6,7 @@ export declare class MysqlIntrospector implements DatabaseIntrospector {
     /**
      * Get schema metadata.
      */
-    getSchemas(): Promise<SchemaMetadata[]>;
+    getSchemas(options?: DatabaseSchemaMetadataOptions): Promise<SchemaMetadata[]>;
     /**
      * Get tables and views metadata.
      */

package/dist/dialect/mysql/mysql-introspector.js

@@ -2,18 +2,27 @@
 import { DEFAULT_MIGRATION_LOCK_TABLE, DEFAULT_MIGRATION_TABLE, } from '../../migration/migrator.js';
 import { freeze } from '../../util/object-utils.js';
 import { sql } from '../../raw-builder/sql.js';
+const SYSTEM_DATABASES = [
+    'information_schema',
+    'mysql',
+    'performance_schema',
+    'sys',
+    'ndbinfo',
+];
 export class MysqlIntrospector {
     #db;
     constructor(db) {
         this.#db = db;
     }
-    async getSchemas() {
-        let rawSchemas = await this.#db
+    async getSchemas(options = {}) {
+        let query = this.#db
             .selectFrom('information_schema.schemata')
-            .select('schema_name')
-            .$castTo()
-            .execute();
-        return rawSchemas.map((it) => ({ name: it.SCHEMA_NAME }));
+            .select('schema_name as name')
+            .$narrowType();
+        if (options.where) {
+            query = query.where(options.where({ schema: sql.ref('schema_name') }));
+        }
+        return await query.execute();
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
@@ -28,34 +37,48 @@ export class MysqlIntrospector {
             'columns.TABLE_NAME',
             'columns.TABLE_SCHEMA',
             'tables.TABLE_TYPE',
+            'tables.TABLE_COMMENT',
             'tables.ENGINE',
             'columns.IS_NULLABLE',
             'columns.DATA_TYPE',
             'columns.EXTRA',
             'columns.COLUMN_COMMENT',
         ])
-            .where('columns.TABLE_SCHEMA', '=', sql `database()`)
+            .where('columns.TABLE_SCHEMA', 'not in', SYSTEM_DATABASES)
+            .orderBy('columns.TABLE_SCHEMA')
             .orderBy('columns.TABLE_NAME')
             .orderBy('columns.ORDINAL_POSITION')
             .$castTo();
+        if (!options.withNonDefaultDatabases) {
+            query = query.where('columns.TABLE_SCHEMA', '=', sql `database()`);
+        }
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('columns.TABLE_NAME', '!=', DEFAULT_MIGRATION_TABLE)
                 .where('columns.TABLE_NAME', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
+        if (options.where) {
+            query = query.where(options.where({
+                schema: sql.ref('columns.TABLE_SCHEMA'),
+                table: sql.ref('columns.TABLE_NAME'),
+            }));
+        }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);
     }
     #parseTableMetadata(columns) {
         return columns.reduce((tables, it) => {
-            let table = tables.find((tbl) => tbl.name === it.TABLE_NAME);
+            let table = tables.find((tbl) => tbl.name === it.TABLE_NAME && tbl.schema === it.TABLE_SCHEMA);
             if (!table) {
                 table = freeze({
-                    name: it.TABLE_NAME,
-                    isView: it.TABLE_TYPE === 'VIEW',
+                    columns: [],
+                    comment: it.TABLE_TYPE === 'VIEW' || it.TABLE_COMMENT === ''
+                        ? undefined
+                        : it.TABLE_COMMENT,
                     isForeign: it.ENGINE === 'FEDERATED',
+                    isView: it.TABLE_TYPE === 'VIEW',
+                    name: it.TABLE_NAME,
                     schema: it.TABLE_SCHEMA,
-                    columns: [],
                 });
                 tables.push(table);
             }

package/dist/dialect/postgres/postgres-introspector.d.ts

@@ -1,4 +1,4 @@
-import type { DatabaseIntrospector, DatabaseMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
+import type { DatabaseIntrospector, DatabaseMetadataOptions, DatabaseSchemaMetadataOptions, SchemaMetadata, TableMetadata } from '../database-introspector.js';
 import type { Kysely } from '../../kysely.js';
 export declare class PostgresIntrospector implements DatabaseIntrospector {
     #private;
@@ -6,7 +6,7 @@ export declare class PostgresIntrospector implements DatabaseIntrospector {
     /**
      * Get schema metadata.
      */
-    getSchemas(): Promise<SchemaMetadata[]>;
+    getSchemas(options?: DatabaseSchemaMetadataOptions): Promise<SchemaMetadata[]>;
     /**
      * Get tables and views metadata.
      */

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

@@ -7,13 +7,15 @@ export class PostgresIntrospector {
     constructor(db) {
         this.#db = db;
     }
-    async getSchemas() {
-        let rawSchemas = await this.#db
+    async getSchemas(options = {}) {
+        let query = this.#db
             .selectFrom('pg_catalog.pg_namespace')
-            .select('nspname')
-            .$castTo()
-            .execute();
-        return rawSchemas.map((it) => ({ name: it.nspname }));
+            .select('nspname as name')
+            .$narrowType();
+        if (options.where) {
+            query = query.where(options.where({ schema: sql.ref('nspname') }));
+        }
+        return await query.execute();
     }
     async getTables(options = { withInternalKyselyTables: false }) {
         let query = this.#db
@@ -36,12 +38,14 @@ export class PostgresIntrospector {
             'ns.nspname as schema',
             'typ.typname as type',
             'dtns.nspname as type_schema',
+            sql `obj_description(c.oid, 'pg_class')`.as('table_description'),
             sql `col_description(a.attrelid, a.attnum)`.as('column_description'),
             sql `pg_get_serial_sequence(quote_ident(ns.nspname) || '.' || quote_ident(c.relname), a.attname)`.as('auto_incrementing'),
         ])
             .where('c.relkind', 'in', [
             'r' /*regular table*/,
             'v' /*view*/,
+            'm' /*materialized view*/,
             'p' /*partitioned table*/,
             'f' /*foreign table*/,
         ])
@@ -63,6 +67,12 @@ export class PostgresIntrospector {
                 .where('c.relname', '!=', DEFAULT_MIGRATION_TABLE)
                 .where('c.relname', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
+        if (options.where) {
+            query = query.where(options.where({
+                schema: sql.ref('ns.nspname'),
+                table: sql.ref('c.relname'),
+            }));
+        }
         const rawColumns = await query.execute();
         return this.#parseTableMetadata(rawColumns);
     }
@@ -79,8 +89,9 @@ export class PostgresIntrospector {
             if (!table) {
                 table = freeze({
                     columns: [],
+                    comment: column.table_description ?? undefined,
                     isForeign: column.table_type === 'f',
-                    isView: column.table_type === 'v',
+                    isView: column.table_type === 'v' || column.table_type === 'm',
                     name: column.table,
                     schema: column.schema,
                 });

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

@@ -1,5 +1,4 @@
 /// <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';
@@ -68,14 +67,14 @@ class SqliteConnection {
             rows: [],
         };
     }
-    async *streamQuery(compiledQuery, _chunkSize) {
-        const { sql, parameters, query } = compiledQuery;
-        const stmt = this.#db.prepare(sql);
-        if (!SelectQueryNode.is(query)) {
-            throw new Error('Sqlite driver only supports streaming of select queries');
+    async *streamQuery(compiledQuery) {
+        const { sql, parameters } = compiledQuery;
+        const statement = this.#db.prepare(sql);
+        if (!statement.reader) {
+            throw new Error('Sqlite driver only supports streaming of queries that return rows');
         }
-        const iter = stmt.iterate(parameters);
-        for (const row of iter) {
+        const rows = statement.iterate(parameters);
+        for (const row of rows) {
             yield {
                 rows: [row],
             };

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

@@ -25,6 +25,9 @@ export class SqliteIntrospector {
                 .where('name', '!=', DEFAULT_MIGRATION_TABLE)
                 .where('name', '!=', DEFAULT_MIGRATION_LOCK_TABLE);
         }
+        if (options.where) {
+            tablesQuery = tablesQuery.where(options.where({ table: sql.ref('name') }));
+        }
         return tablesQuery;
     }
     async #getTableMetadata(options) {
@@ -70,9 +73,6 @@ export class SqliteIntrospector {
                 }
             }
             return {
-                name: name,
-                isView: type === 'view',
-                isForeign: false,
                 columns: columns.map((col) => ({
                     name: col.name,
                     dataType: col.type,
@@ -81,6 +81,10 @@ export class SqliteIntrospector {
                     hasDefaultValue: col.dflt_value != null,
                     comment: undefined,
                 })),
+                comment: undefined,
+                isForeign: false,
+                isView: type === 'view',
+                name,
             };
         });
     }

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

@@ -29,8 +29,8 @@ import type { Driver } from './driver.js';
  * })
  * ```
  *
- * You can use it to build a query and compile it to SQL but trying to
- * execute the query will throw an error.
+ * You can use it to build a query and compile it to SQL. Executing queries
+ * returns empty results without communicating with a database.
  *
  * ```ts
  * const { sql } = db.selectFrom('person').selectAll().compile()

package/dist/driver/dummy-driver.js

@@ -28,8 +28,8 @@
  * })
  * ```
  *
- * You can use it to build a query and compile it to SQL but trying to
- * execute the query will throw an error.
+ * You can use it to build a query and compile it to SQL. Executing queries
+ * returns empty results without communicating with a database.
  *
  * ```ts
  * const { sql } = db.selectFrom('person').selectAll().compile()