kysely 0.9.1 → 0.9.5

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

@@ -8,6 +8,16 @@ import { Dialect } from '../dialect.js';
 import { DatabaseIntrospector } from '../../introspection/database-introspector.js';
 import { DialectAdapter } from '../dialect-adapter.js';
 import { DatabaseConnection } from '../../driver/database-connection.js';
+/**
+ * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
+ *
+ * The {@link PostgresDialectConfig | configuration} passed to the constructor
+ * is given as-is to the pg library's [Pool](https://node-postgres.com/api/pool)
+ * constructor. See the following two links for more documentation:
+ *
+ * https://node-postgres.com/api/pool
+ * https://node-postgres.com/api/client
+ */
 export declare class PostgresDialect implements Dialect {
     #private;
     constructor(config: PostgresDialectConfig);
@@ -19,7 +29,7 @@ export declare class PostgresDialect implements Dialect {
 /**
  * Config for the postgres dialect.
  *
- * This interface is equal to `pg` library's pool config:
+ * This interface is equal to `pg` library's `Pool` config:
  *
  * https://node-postgres.com/api/pool
  * https://node-postgres.com/api/client
@@ -105,6 +115,8 @@ export interface PostgresDialectConfig {
     application_name?: string;
     /**
      * Called once for each created connection.
+     *
+     * This is a Kysely specific feature and does not come from the `pg` module.
      */
     onCreateConnection?: (connection: DatabaseConnection) => Promise<void>;
     keepAlive?: boolean;

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

@@ -2,6 +2,16 @@ import { PostgresDriver } from './postgres-driver.js';
 import { PostgresIntrospector } from './postgres-introspector.js';
 import { PostgresQueryCompiler } from './postgres-query-compiler.js';
 import { PostgresAdapter } from './postgres-adapter.js';
+/**
+ * PostgreSQL dialect that uses the [pg](https://node-postgres.com/) library.
+ *
+ * The {@link PostgresDialectConfig | configuration} passed to the constructor
+ * is given as-is to the pg library's [Pool](https://node-postgres.com/api/pool)
+ * constructor. See the following two links for more documentation:
+ *
+ * https://node-postgres.com/api/pool
+ * https://node-postgres.com/api/client
+ */
 export class PostgresDialect {
     #config;
     constructor(config) {

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

@@ -13,10 +13,10 @@ export class PostgresDriver {
         // installed. As you can see, there IS an import from `pg` at the
         // top level too, but that's only for types. It doesn't get compiled
         // into javascript. You can check the built javascript code.
-        const PoolConstrucor = await importPgPool();
+        const PoolConstructor = await importPgPool();
         // Use the `pg` module's own pool. All drivers should use the
         // pool provided by the database library if possible.
-        this.#pool = new PoolConstrucor(this.#config);
+        this.#pool = new PoolConstructor(this.#config);
     }
     async acquireConnection() {
         const client = await this.#pool.connect();

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

@@ -1,4 +1,4 @@
 import { DefaultQueryCompiler } from '../../query-compiler/default-query-compiler.js';
-// The default query compiler is for postgres dialect.
+// The default query compiler is for PostgreSQL.
 export class PostgresQueryCompiler extends DefaultQueryCompiler {
 }

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

@@ -1,3 +1,4 @@
+import { Log } from '../util/log.js';
 import { DatabaseConnection } from './database-connection.js';
 import { Driver, TransactionSettings } from './driver.js';
 /**
@@ -7,10 +8,10 @@ import { Driver, TransactionSettings } from './driver.js';
  */
 export declare class RuntimeDriver implements Driver {
     #private;
-    constructor(driver: Driver);
+    constructor(driver: Driver, log: Log);
     init(): Promise<void>;
     acquireConnection(): Promise<DatabaseConnection>;
-    releaseConnection(connection: DatabaseConnection): Promise<void>;
+    releaseConnection(runtimeConnection: DatabaseConnection): Promise<void>;
     beginTransaction(connection: DatabaseConnection, settings: TransactionSettings): Promise<void>;
     commitTransaction(connection: DatabaseConnection): Promise<void>;
     rollbackTransaction(connection: DatabaseConnection): Promise<void>;

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

@@ -5,10 +5,13 @@
  */
 export class RuntimeDriver {
     #driver;
+    #log;
     #initPromise;
     #destroyPromise;
-    constructor(driver) {
+    #connections = new WeakMap();
+    constructor(driver, log) {
         this.#driver = driver;
+        this.#log = log;
     }
     async init() {
         if (!this.#initPromise) {
@@ -21,10 +24,18 @@ export class RuntimeDriver {
     }
     async acquireConnection() {
         await this.init();
-        return this.#driver.acquireConnection();
+        const connection = await this.#driver.acquireConnection();
+        let runtimeConnection = this.#connections.get(connection);
+        if (!runtimeConnection) {
+            runtimeConnection = new RuntimeConnection(connection, this.#log);
+            this.#connections.set(connection, runtimeConnection);
+        }
+        return runtimeConnection;
     }
-    releaseConnection(connection) {
-        return this.#driver.releaseConnection(connection);
+    async releaseConnection(runtimeConnection) {
+        if (runtimeConnection instanceof RuntimeConnection) {
+            await this.#driver.releaseConnection(runtimeConnection.connection);
+        }
     }
     beginTransaction(connection, settings) {
         return this.#driver.beginTransaction(connection, settings);
@@ -49,3 +60,45 @@ export class RuntimeDriver {
         await this.#destroyPromise;
     }
 }
+class RuntimeConnection {
+    #connection;
+    #log;
+    get connection() {
+        return this.#connection;
+    }
+    constructor(connection, log) {
+        this.#connection = connection;
+        this.#log = log;
+    }
+    async executeQuery(compiledQuery) {
+        const startTime = process.hrtime.bigint();
+        try {
+            return await this.#connection.executeQuery(compiledQuery);
+        }
+        catch (error) {
+            this.#logError(error);
+            throw error;
+        }
+        finally {
+            this.#logQuery(compiledQuery, startTime);
+        }
+    }
+    #logError(error) {
+        this.#log.error(() => ({
+            level: 'error',
+            error,
+        }));
+    }
+    #logQuery(compiledQuery, startTime) {
+        this.#log.query(() => ({
+            level: 'query',
+            sql: compiledQuery.sql,
+            queryDurationMillis: this.#calculateDurationMillis(startTime),
+        }));
+    }
+    #calculateDurationMillis(startTime) {
+        const endTime = process.hrtime.bigint();
+        const durationNanos = Number(endTime - startTime);
+        return durationNanos / 1_000_000;
+    }
+}

package/dist/esm/index.d.ts

@@ -110,7 +110,7 @@ export * from './operation-node/operation-node-source.js';
 export * from './operation-node/order-by-node.js';
 export * from './introspection/database-introspector.js';
 export * from './util/compilable.js';
-export { AnyColumn, UnknownRow as AnyRow } from './util/type-utils.js';
+export { AnyColumn, UnknownRow, AnyQueryBuilder } from './util/type-utils.js';
 export { SelectExpression, SelectExpressionOrList, } from './parser/select-parser.js';
 export { ReferenceExpression, ReferenceExpressionOrList, } from './parser/reference-parser.js';
 export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.js';
@@ -120,3 +120,4 @@ export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-
 export { InsertObject } from './parser/insert-values-parser.js';
 export { MutationObject } from './parser/update-set-parser.js';
 export { OrderByExpression, OrderByDirectionExpression, } from './parser/order-by-parser.js';
+export { UnionExpression } from './parser/union-parser.js';

package/dist/esm/kysely.d.ts

@@ -10,6 +10,7 @@ import { DatabaseIntrospector } from './introspection/database-introspector.js';
 import { Driver, IsolationLevel } from './driver/driver.js';
 import { ParseContext } from './parser/parse-context.js';
 import { FunctionBuilder } from './query-builder/function-builder.js';
+import { LogLevel } from './util/log.js';
 /**
  * The main Kysely class.
  *
@@ -127,15 +128,20 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      */
     get fn(): FunctionBuilder<DB, keyof DB>;
     /**
-     * Starts a transaction. If the callback throws the transaction is rolled back,
-     * otherwise it's committed.
+     * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
      *
-     * @example
-     * In the example below if either query fails or `someFunction` throws, both inserts
-     * will be rolled back. Otherwise the transaction will be committed by the time the
-     * `transaction` function returns the output value. The output value of the
-     * `transaction` method is the value returned from the callback.
+     * The returned {@link TransactionBuilder} can be used to configure the transaction. The
+     * {@link TransactionBuilder.execute} method can then be called to run the transaction.
+     * {@link TransactionBuilder.execute} takes a function that is run inside the
+     * transaction. If the function throws, the transaction is rolled back. Otherwise
+     * the transaction is committed.
+     *
+     * The callback function passed to the {@link TransactionBuilder.execute | execute}
+     * method gets the transaction object as its only argument. The transaction is
+     * of type {@link Transaction} which inherits {@link Kysely}. Any query
+     * started through the transaction object is executed inside the transaction.
      *
+     * @example
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
@@ -188,6 +194,10 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * ```
      */
     connection(): ConnectionBuilder<DB>;
+    /**
+     * Returns a copy of this Kysely instance with the given plugin installed.
+     */
+    withPlugin(plugin: KyselyPlugin): Kysely<DB>;
     /**
      * Returns a copy of this Kysely instance without any plugins.
      */
@@ -220,8 +230,20 @@ export interface KyselyProps {
 }
 export declare function isKyselyProps(obj: unknown): obj is KyselyProps;
 export interface KyselyConfig {
-    dialect: Dialect;
-    plugins?: KyselyPlugin[];
+    readonly dialect: Dialect;
+    readonly plugins?: KyselyPlugin[];
+    /**
+     * A list of log levels to log.
+     *
+     * Currently there's only two levels: `query` and `error`.
+     * This will be expanded based on user feedback later.
+     *
+     * Log levels:
+     *
+     *  - query: Log each query's SQL and duration using console.log
+     *  - error: Log all query errors using console.error
+     */
+    readonly log?: ReadonlyArray<LogLevel>;
 }
 export declare class ConnectionBuilder<DB> {
     #private;

package/dist/esm/kysely.js

@@ -12,6 +12,7 @@ import { TRANSACTION_ISOLATION_LEVELS, } from './driver/driver.js';
 import { preventAwait } from './util/prevent-await.js';
 import { DefaultParseContext } from './parser/parse-context.js';
 import { FunctionBuilder } from './query-builder/function-builder.js';
+import { Log } from './util/log.js';
 /**
  * The main Kysely class.
  *
@@ -57,15 +58,16 @@ export class Kysely extends QueryCreator {
     constructor(args) {
         if (isKyselyProps(args)) {
             super({ executor: args.executor, parseContext: args.parseContext });
-            this.#props = freeze(args);
+            this.#props = freeze({ ...args });
         }
         else {
             const dialect = args.dialect;
             const driver = dialect.createDriver();
             const compiler = dialect.createQueryCompiler();
             const adapter = dialect.createAdapter();
+            const log = new Log(args.log ?? []);
             const parseContext = new DefaultParseContext(adapter);
-            const runtimeDriver = new RuntimeDriver(driver);
+            const runtimeDriver = new RuntimeDriver(driver, log);
             const connectionProvider = new DefaultConnectionProvider(runtimeDriver);
             const executor = new DefaultQueryExecutor(compiler, connectionProvider, args.plugins ?? []);
             super({ executor, parseContext });
@@ -163,15 +165,20 @@ export class Kysely extends QueryCreator {
         return new FunctionBuilder({ executor: this.#props.executor });
     }
     /**
-     * Starts a transaction. If the callback throws the transaction is rolled back,
-     * otherwise it's committed.
+     * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
      *
-     * @example
-     * In the example below if either query fails or `someFunction` throws, both inserts
-     * will be rolled back. Otherwise the transaction will be committed by the time the
-     * `transaction` function returns the output value. The output value of the
-     * `transaction` method is the value returned from the callback.
+     * The returned {@link TransactionBuilder} can be used to configure the transaction. The
+     * {@link TransactionBuilder.execute} method can then be called to run the transaction.
+     * {@link TransactionBuilder.execute} takes a function that is run inside the
+     * transaction. If the function throws, the transaction is rolled back. Otherwise
+     * the transaction is committed.
+     *
+     * The callback function passed to the {@link TransactionBuilder.execute | execute}
+     * method gets the transaction object as its only argument. The transaction is
+     * of type {@link Transaction} which inherits {@link Kysely}. Any query
+     * started through the transaction object is executed inside the transaction.
      *
+     * @example
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
@@ -228,6 +235,15 @@ export class Kysely extends QueryCreator {
     connection() {
         return new ConnectionBuilder({ ...this.#props });
     }
+    /**
+     * Returns a copy of this Kysely instance with the given plugin installed.
+     */
+    withPlugin(plugin) {
+        return new Kysely({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
     /**
      * Returns a copy of this Kysely instance without any plugins.
      */

package/dist/esm/migration/migration.d.ts

@@ -24,6 +24,38 @@ export declare class MigrationModule {
      *   path.join(__dirname, 'migrations')
      * )
      * ```
+     *
+     * In the next example, we use a record of migration objects instead of file folder path.
+     * The keys in the object are migration names that can be anything you want. The order of
+     * the migrations is determined based on the alphabetical order of the keys in the record.
+     * This can be useful if you are using a bundler like webpack or esbuild.
+     *
+     * @example
+     * ```ts
+     * await db.migration.migrateToLatest({
+     *   migration1: {
+     *     async up(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     },
+     *
+     *     async down(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     }
+     *   },
+     *
+     *   migration2: {
+     *     async up(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     },
+     *
+     *     async down(db: Kysely<any>): Promise<void> {
+     *       ...
+     *     }
+     *   },
+     *
+     *  ...
+     * })
+     * ```
      */
     migrateToLatest(migrationsFolderPath: string): Promise<void>;
     migrateToLatest(allMigrations: Record<string, Migration>): Promise<void>;

package/dist/esm/operation-node/join-node.d.ts

@@ -21,5 +21,6 @@ export declare const JoinNode: Readonly<{
     is(node: OperationNode): node is JoinNode;
     create(joinType: JoinType, table: JoinTableNode): JoinNode;
     createWithOn(joinType: JoinType, table: JoinTableNode, on: JoinNodeOnNode): JoinNode;
-    cloneWithOn(joinNode: JoinNode, op: 'And' | 'Or', on: JoinNodeOnNode): JoinNode;
+    cloneWithOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
+    cloneWithOrOn(joinNode: JoinNode, on: JoinNodeOnNode): JoinNode;
 }>;

package/dist/esm/operation-node/join-node.js

@@ -24,14 +24,16 @@ export const JoinNode = freeze({
             on,
         });
     },
-    cloneWithOn(joinNode, op, on) {
+    cloneWithOn(joinNode, on) {
         return freeze({
             ...joinNode,
-            on: joinNode.on
-                ? op === 'And'
-                    ? AndNode.create(joinNode.on, on)
-                    : OrNode.create(joinNode.on, on)
-                : on,
+            on: joinNode.on ? AndNode.create(joinNode.on, on) : on,
+        });
+    },
+    cloneWithOrOn(joinNode, on) {
+        return freeze({
+            ...joinNode,
+            on: joinNode.on ? OrNode.create(joinNode.on, on) : on,
         });
     },
 });

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -57,6 +57,7 @@ import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
+import { UnionNode } from './union-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -129,6 +130,7 @@ export declare class OperationNodeTransformer {
     protected transformPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): PrimaryKeyConstraintNode;
     protected transformUniqueConstraint(node: UniqueConstraintNode): UniqueConstraintNode;
     protected transformForeignKeyConstraint(node: ForeignKeyConstraintNode): ForeignKeyConstraintNode;
+    protected transformUnion(node: UnionNode): UnionNode;
     protected transformReferences(node: ReferencesNode): ReferencesNode;
     protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
     protected transformWith(node: WithNode): WithNode;

package/dist/esm/operation-node/operation-node-transformer.js

@@ -89,6 +89,7 @@ export class OperationNodeTransformer {
         AddConstraintNode: this.transformAddConstraint.bind(this),
         DropConstraintNode: this.transformDropConstraint.bind(this),
         ForeignKeyConstraintNode: this.transformForeignKeyConstraint.bind(this),
+        UnionNode: this.transformUnion.bind(this),
     };
     transformNode = (node) => {
         if (!node) {
@@ -121,6 +122,7 @@ export class OperationNodeTransformer {
             offset: this.transformNode(node.offset),
             with: this.transformNode(node.with),
             having: this.transformNode(node.having),
+            union: this.transformNodeList(node.union),
         };
     }
     transformSelection(node) {
@@ -400,6 +402,13 @@ export class OperationNodeTransformer {
             onUpdate: node.onUpdate,
         };
     }
+    transformUnion(node) {
+        return {
+            kind: 'UnionNode',
+            union: this.transformNode(node.union),
+            all: node.all,
+        };
+    }
     transformReferences(node) {
         return {
             kind: 'ReferencesNode',

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -57,66 +57,68 @@ import { ForeignKeyConstraintNode } from './foreign-key-constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
 import { ModifyColumnNode } from './modify-column-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
-export declare class OperationNodeVisitor {
+import { UnionNode } from './union-node.js';
+export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
     protected readonly visitNode: (node: OperationNode) => void;
-    protected visitSelectQuery(node: SelectQueryNode): void;
-    protected visitSelection(node: SelectionNode): void;
-    protected visitColumn(node: ColumnNode): void;
-    protected visitAlias(node: AliasNode): void;
-    protected visitTable(node: TableNode): void;
-    protected visitFrom(node: FromNode): void;
-    protected visitReference(node: ReferenceNode): void;
-    protected visitFilter(node: FilterNode): void;
-    protected visitAnd(node: AndNode): void;
-    protected visitOr(node: OrNode): void;
-    protected visitValueList(node: ValueListNode): void;
-    protected visitParens(node: ParensNode): void;
-    protected visitJoin(node: JoinNode): void;
-    protected visitRaw(node: RawNode): void;
-    protected visitWhere(node: WhereNode): void;
-    protected visitInsertQuery(node: InsertQueryNode): void;
-    protected visitDeleteQuery(node: DeleteQueryNode): void;
-    protected visitReturning(node: ReturningNode): void;
-    protected visitCreateTable(node: CreateTableNode): void;
-    protected visitAddColumn(node: AddColumnNode): void;
-    protected visitColumnDefinition(node: ColumnDefinitionNode): void;
-    protected visitDropTable(node: DropTableNode): void;
-    protected visitOrderBy(node: OrderByNode): void;
-    protected visitOrderByItem(node: OrderByItemNode): void;
-    protected visitGroupBy(node: GroupByNode): void;
-    protected visitGroupByItem(node: GroupByItemNode): void;
-    protected visitUpdateQuery(node: UpdateQueryNode): void;
-    protected visitColumnUpdate(node: ColumnUpdateNode): void;
-    protected visitLimit(node: LimitNode): void;
-    protected visitOffset(node: OffsetNode): void;
-    protected visitOnConflict(node: OnConflictNode): void;
-    protected visitOnDuplicateKey(node: OnDuplicateKeyNode): void;
-    protected visitCreateIndex(node: CreateIndexNode): void;
-    protected visitList(node: ListNode): void;
-    protected visitDropIndex(node: DropIndexNode): void;
-    protected visitPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): void;
-    protected visitUniqueConstraint(node: UniqueConstraintNode): void;
-    protected visitReferences(node: ReferencesNode): void;
-    protected visitCheckConstraint(node: CheckConstraintNode): void;
-    protected visitWith(node: WithNode): void;
-    protected visitCommonTableExpression(node: CommonTableExpressionNode): void;
-    protected visitHaving(node: HavingNode): void;
-    protected visitCreateSchema(node: CreateSchemaNode): void;
-    protected visitDropSchema(node: DropSchemaNode): void;
-    protected visitAlterTable(node: AlterTableNode): void;
-    protected visitDropColumn(node: DropColumnNode): void;
-    protected visitRenameColumn(node: RenameColumnNode): void;
-    protected visitAlterColumn(node: AlterColumnNode): void;
-    protected visitModifyColumn(node: ModifyColumnNode): void;
-    protected visitAddConstraint(node: AddConstraintNode): void;
-    protected visitDropConstraint(node: DropConstraintNode): void;
-    protected visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
-    protected visitDataType(node: DataTypeNode): void;
-    protected visitSelectAll(_: SelectAllNode): void;
-    protected visitIdentifier(_: IdentifierNode): void;
-    protected visitValue(_: ValueNode): void;
-    protected visitPrimitiveValueList(_: PrimitiveValueListNode): void;
-    protected visitOperator(node: OperatorNode): void;
+    protected abstract visitSelectQuery(node: SelectQueryNode): void;
+    protected abstract visitSelection(node: SelectionNode): void;
+    protected abstract visitColumn(node: ColumnNode): void;
+    protected abstract visitAlias(node: AliasNode): void;
+    protected abstract visitTable(node: TableNode): void;
+    protected abstract visitFrom(node: FromNode): void;
+    protected abstract visitReference(node: ReferenceNode): void;
+    protected abstract visitFilter(node: FilterNode): void;
+    protected abstract visitAnd(node: AndNode): void;
+    protected abstract visitOr(node: OrNode): void;
+    protected abstract visitValueList(node: ValueListNode): void;
+    protected abstract visitParens(node: ParensNode): void;
+    protected abstract visitJoin(node: JoinNode): void;
+    protected abstract visitRaw(node: RawNode): void;
+    protected abstract visitWhere(node: WhereNode): void;
+    protected abstract visitInsertQuery(node: InsertQueryNode): void;
+    protected abstract visitDeleteQuery(node: DeleteQueryNode): void;
+    protected abstract visitReturning(node: ReturningNode): void;
+    protected abstract visitCreateTable(node: CreateTableNode): void;
+    protected abstract visitAddColumn(node: AddColumnNode): void;
+    protected abstract visitColumnDefinition(node: ColumnDefinitionNode): void;
+    protected abstract visitDropTable(node: DropTableNode): void;
+    protected abstract visitOrderBy(node: OrderByNode): void;
+    protected abstract visitOrderByItem(node: OrderByItemNode): void;
+    protected abstract visitGroupBy(node: GroupByNode): void;
+    protected abstract visitGroupByItem(node: GroupByItemNode): void;
+    protected abstract visitUpdateQuery(node: UpdateQueryNode): void;
+    protected abstract visitColumnUpdate(node: ColumnUpdateNode): void;
+    protected abstract visitLimit(node: LimitNode): void;
+    protected abstract visitOffset(node: OffsetNode): void;
+    protected abstract visitOnConflict(node: OnConflictNode): void;
+    protected abstract visitOnDuplicateKey(node: OnDuplicateKeyNode): void;
+    protected abstract visitCreateIndex(node: CreateIndexNode): void;
+    protected abstract visitDropIndex(node: DropIndexNode): void;
+    protected abstract visitList(node: ListNode): void;
+    protected abstract visitPrimaryKeyConstraint(node: PrimaryKeyConstraintNode): void;
+    protected abstract visitUniqueConstraint(node: UniqueConstraintNode): void;
+    protected abstract visitReferences(node: ReferencesNode): void;
+    protected abstract visitCheckConstraint(node: CheckConstraintNode): void;
+    protected abstract visitWith(node: WithNode): void;
+    protected abstract visitCommonTableExpression(node: CommonTableExpressionNode): void;
+    protected abstract visitHaving(node: HavingNode): void;
+    protected abstract visitCreateSchema(node: CreateSchemaNode): void;
+    protected abstract visitDropSchema(node: DropSchemaNode): void;
+    protected abstract visitAlterTable(node: AlterTableNode): void;
+    protected abstract visitDropColumn(node: DropColumnNode): void;
+    protected abstract visitRenameColumn(node: RenameColumnNode): void;
+    protected abstract visitAlterColumn(node: AlterColumnNode): void;
+    protected abstract visitModifyColumn(node: ModifyColumnNode): void;
+    protected abstract visitAddConstraint(node: AddConstraintNode): void;
+    protected abstract visitDropConstraint(node: DropConstraintNode): void;
+    protected abstract visitForeignKeyConstraint(node: ForeignKeyConstraintNode): void;
+    protected abstract visitUnion(node: UnionNode): void;
+    protected abstract visitDataType(node: DataTypeNode): void;
+    protected abstract visitSelectAll(_: SelectAllNode): void;
+    protected abstract visitIdentifier(_: IdentifierNode): void;
+    protected abstract visitValue(_: ValueNode): void;
+    protected abstract visitPrimitiveValueList(_: PrimitiveValueListNode): void;
+    protected abstract visitOperator(node: OperatorNode): void;
 }