kysely 0.19.8 → 0.19.11

package/README.md

@@ -5,21 +5,20 @@
 
 # [Kysely](https://koskimas.github.io/kysely/index.html)
 
-A type-safe and autocompletion-friendly typescript SQL query builder. Inspired by [knex](http://knexjs.org/).
-Mainly developed for [node.js](https://nodejs.org/en/) but also runs on [deno](https://deno.land/) and
-in the browser.
+Kysely (pronounce “Key-Seh-Lee”) is a type-safe and autocompletion-friendly typescript SQL query builder. Inspired by
+[knex](http://knexjs.org/). Mainly developed for [node.js](https://nodejs.org/en/) but also runs on [deno](https://deno.land/)
+and in the browser.
 
 ![](https://github.com/koskimas/kysely/blob/master/assets/demo.gif)
 
 Kysely makes sure you only refer to tables and columns that are visible to the part of the query
-you are writing. The result type only has the selected columns with correct types and aliases. As an
+you're writing. The result type only has the selected columns with correct types and aliases. As an
 added bonus you get autocompletion for all that stuff.
 
-As you can see in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
+As shown in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
 the alias given to `pet.name` and add the `pet_name` column to the result row type. Kysely is able to infer
 column names, aliases and types from selected subqueries, joined subqueries, `with` statements and pretty
-much anything you can think of. Typescript is always there for you offering completions and making sure
-you build a valid query.
+much anything you can think of.
 
 Of course there are cases where things cannot be typed at compile time, and Kysely offers escape
 hatches for these situations. See the [sql template tag](https://koskimas.github.io/kysely/modules.html#sql) 
@@ -33,14 +32,21 @@ You can find a more thorough introduction [here](https://www.jakso.me/blog/kysel
 # Table of contents
 
 - [Installation](#installation)
+    - [3rd party dialects](#3rd-party-dialects)
 - [Minimal example](#minimal-example)
+- [Generating types](#generating-types)
 - [Query examples](#query-examples)
-- [Recipes](https://github.com/koskimas/kysely/tree/master/recipes)
+  - [Select queries](#select-queries)
+    - [Stream select query results](#stream-select-query-results)
+  - [Update queries](#update-queries)
+  - [Insert queries](#insert-queries)
+  - [Delete queries](#delete-queries)
 - [Migrations](#migrations)
+    - [PostgreSQL migration example](#postgresql-migration-example)
+    - [MySQL migration example](#mysql-migration-example)
 - [Deno](#deno)
 - [Browser](#browser)
-- [API reference](https://koskimas.github.io/kysely/index.html)
-- [Changelog](https://github.com/koskimas/kysely/releases)
+- [Why not just contribute to knex](#why-not-just-contribute-to-knex)
 
 # Installation
 
@@ -166,6 +172,11 @@ type InsertablePerson = Insertable<PersonTable>
 type UpdateablePerson = Updateable<PersonTable>
 ```
 
+# Generating types
+
+If you want to generate the table types automatically from the database schema please
+check out [this awesome project](https://github.com/RobinBlomberg/kysely-codegen).
+
 # Query examples
 
 ## Select queries
@@ -175,6 +186,48 @@ You can find examples of select queries in the documentation of the
 the [where method](https://koskimas.github.io/kysely/classes/SelectQueryBuilder.html#where)
 among other places.
 
+### Stream select query results
+
+*Currently only supported by `postgres` and `mysql` dialects.*
+
+```ts
+import { Pool } from 'pg'
+// or `import * as Cursor from 'pg-cursor'` depending on your tsconfig
+import Cursor from 'pg-cursor'
+import {
+    Kysely,
+    PostgresDialect,
+} from 'kysely'
+
+const db = new Kysely<Database>({
+    // PostgresDialect requires the Cursor dependency
+    dialect: new PostgresDialect({
+        pool: new Pool({
+            host: 'localhost',
+            database: 'kysely_test'
+        }),
+        cursor: Cursor
+    }),
+
+    // MysqlDialect doesn't require any special configuration
+})
+
+async function demo() {
+    for await (const male of db.selectFrom("person")
+        .selectAll()
+        .where("person.gender", "=", "male")
+        .stream()) {
+        console.log(`Hello mr. ${male.first_name}!`)
+
+        if (male.first_name === "John") {
+          // After this line the db connection is released and no more 
+          // rows are streamed from the database to the client
+          break;
+        }
+    }
+}
+```
+
 ## Update queries
 
 See the [set method](https://koskimas.github.io/kysely/classes/UpdateQueryBuilder.html#set) and the
@@ -208,10 +261,11 @@ export async function down(db: Kysely<any>): Promise<void> {
 }
 ```
 
-The `up` function is called when you update your database schema to next version and `down`
+The `up` function is called when you update your database schema to the next version and `down`
 when you go back to previous version. The only argument for the functions is an instance of
-`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. Migrations
-should never depend on the current code of your app because they need to work even when the app
+`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. 
+
+Migrations should never depend on the current code of your app because they need to work even when the app
 changes. Migrations need to be "frozen in time".
 
 The migrations can use the [Kysely.schema](https://koskimas.github.io/kysely/classes/SchemaModule.html)

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

@@ -31,9 +31,19 @@ export interface MysqlPool {
     end(callback: (error: unknown) => void): void;
 }
 export interface MysqlPoolConnection {
+    query(sql: string, parameters: ReadonlyArray<unknown>): {
+        stream: <T>(options: MysqlStreamOptions) => MysqlStream<T>;
+    };
     query(sql: string, parameters: ReadonlyArray<unknown>, callback: (error: unknown, result: MysqlQueryResult) => void): void;
     release(): void;
 }
+export interface MysqlStreamOptions {
+    highWaterMark?: number;
+    objectMode?: boolean;
+}
+export interface MysqlStream<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
 export interface MysqlOkPacket {
     affectedRows: number;
     insertId: number;

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

@@ -42,6 +42,7 @@ declare class MysqlConnection implements DatabaseConnection {
     #private;
     constructor(rawConnection: MysqlPoolConnection);
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
     [PRIVATE_RELEASE_METHOD](): void;
 }
 export {};

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

@@ -124,6 +124,31 @@ class MysqlConnection {
             });
         });
     }
+    async *streamQuery(compiledQuery, chunkSize) {
+        const stream = this.#rawConnection
+            .query(compiledQuery.sql, compiledQuery.parameters)
+            .stream({
+            objectMode: true,
+        });
+        try {
+            for await (const row of stream) {
+                yield {
+                    rows: [row],
+                };
+            }
+        }
+        catch (ex) {
+            if (ex &&
+                typeof ex === 'object' &&
+                'code' in ex &&
+                // @ts-ignore
+                ex.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+                // Most likely because of https://github.com/mysqljs/mysql/blob/master/lib/protocol/sequences/Query.js#L220
+                return;
+            }
+            throw ex;
+        }
+    }
     [PRIVATE_RELEASE_METHOD]() {
         this.#rawConnection.release();
     }

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

@@ -1,4 +1,14 @@
 import { DatabaseConnection } from '../../driver/database-connection.js';
+export declare type PostgresCursorConstructor = new <T>(sql: string, parameters: readonly unknown[]) => PostgresCursor<T>;
+export declare type PostgresCursor<T> = {
+    state: 'initialized' | 'idle' | 'submitted' | 'busy';
+    read: (rowsCount: number) => Promise<T[]>;
+} | {
+    state: 'done';
+} | {
+    state: 'error';
+    _error: Error;
+};
 /**
  * Config for the PostgreSQL dialect.
  */
@@ -11,6 +21,19 @@ export interface PostgresDialectConfig {
      * https://node-postgres.com/api/pool
      */
     pool: PostgresPool | (() => Promise<PostgresPool>);
+    /**
+     * https://github.com/brianc/node-postgres/tree/master/packages/pg-cursor
+     * ```ts
+     * import Cursor from 'pg-cursor'
+     * // or
+     * import * as Cursor from 'pg-cursor'
+     *
+     * new PostgresDialect({
+     *  cursor: Cursor
+     * })
+     * ```
+     */
+    cursor?: PostgresCursorConstructor;
     /**
      * Called once for each created connection.
      */
@@ -30,6 +53,7 @@ export interface PostgresPool {
 }
 export interface PostgresPoolClient {
     query<R>(sql: string, parameters: ReadonlyArray<unknown>): Promise<PostgresQueryResult<R>>;
+    query<R>(cursor: PostgresCursor<R>): PostgresCursor<R>;
     release(): void;
 }
 export interface PostgresQueryResult<R> {
@@ -37,3 +61,8 @@ export interface PostgresQueryResult<R> {
     rowCount: number;
     rows: R[];
 }
+export interface PostgresStreamOptions {
+}
+export interface PostgresStream<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

package/dist/cjs/dialect/postgres/postgres-driver.d.ts

@@ -1,7 +1,7 @@
 import { DatabaseConnection, QueryResult } from '../../driver/database-connection.js';
 import { Driver, TransactionSettings } from '../../driver/driver.js';
 import { CompiledQuery } from '../../query-compiler/compiled-query.js';
-import { PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
+import { PostgresCursorConstructor, PostgresDialectConfig, PostgresPoolClient } from './postgres-dialect-config.js';
 declare const PRIVATE_RELEASE_METHOD: unique symbol;
 export declare class PostgresDriver implements Driver {
     #private;
@@ -38,10 +38,14 @@ export declare class PostgresDriver implements Driver {
      */
     destroy(): Promise<void>;
 }
+interface PostgresConnectionOptions {
+    cursor: PostgresCursorConstructor | null;
+}
 declare class PostgresConnection implements DatabaseConnection {
     #private;
-    constructor(client: PostgresPoolClient);
+    constructor(client: PostgresPoolClient, options: PostgresConnectionOptions);
     executeQuery<O>(compiledQuery: CompiledQuery): Promise<QueryResult<O>>;
+    streamQuery<O>(compiledQuery: CompiledQuery, chunkSize: number): AsyncIterableIterator<QueryResult<O>>;
     [PRIVATE_RELEASE_METHOD](): void;
 }
 export {};

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

@@ -21,7 +21,9 @@ class PostgresDriver {
         const client = await this.#pool.connect();
         let connection = this.#connections.get(client);
         if (!connection) {
-            connection = new PostgresConnection(client);
+            connection = new PostgresConnection(client, {
+                cursor: this.#config.cursor ?? null,
+            });
             this.#connections.set(client, connection);
             // The driver must take care of calling `onCreateConnection` when a new
             // connection is created. The `pg` module doesn't provide an async hook
@@ -60,8 +62,10 @@ class PostgresDriver {
 exports.PostgresDriver = PostgresDriver;
 class PostgresConnection {
     #client;
-    constructor(client) {
+    #options;
+    constructor(client, options) {
         this.#client = client;
+        this.#options = options;
     }
     async executeQuery(compiledQuery) {
         try {
@@ -82,6 +86,24 @@ class PostgresConnection {
             throw (0, stack_trace_utils_js_1.extendStackTrace)(err, new Error());
         }
     }
+    async *streamQuery(compiledQuery, chunkSize) {
+        if (!this.#options.cursor) {
+            throw new Error("'cursor' is not present in your postgres dialect config. It's required to make streaming work in postgres.");
+        }
+        const cursor = this.#client.query(new this.#options.cursor(compiledQuery.sql, compiledQuery.parameters));
+        while (true) {
+            if (cursor.state === 'done') {
+                break;
+            }
+            if (cursor.state === 'error') {
+                throw cursor._error;
+            }
+            const rows = await cursor.read(chunkSize);
+            yield {
+                rows,
+            };
+        }
+    }
     [PRIVATE_RELEASE_METHOD]() {
         this.#client.release();
     }

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

@@ -69,6 +69,9 @@ class SqliteConnection {
             });
         }
     }
+    async *streamQuery() {
+        throw new Error("Sqlite driver doesn't support streaming");
+    }
 }
 class ConnectionMutex {
     #promise;

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

@@ -6,6 +6,7 @@ import { CompiledQuery } from '../query-compiler/compiled-query.js';
  */
 export interface DatabaseConnection {
     executeQuery<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    streamQuery<R>(compiledQuery: CompiledQuery, chunkSize?: number): AsyncIterableIterator<QueryResult<R>>;
 }
 export interface QueryResult<O> {
     /**

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

@@ -67,4 +67,7 @@ class DummyConnection {
             rows: [],
         };
     }
+    async *streamQuery() {
+        // Nothing to do here.
+    }
 }

package/dist/cjs/index.d.ts

@@ -25,7 +25,9 @@ export * from './query-compiler/default-query-compiler.js';
 export * from './query-compiler/compiled-query.js';
 export * from './schema/schema.js';
 export * from './schema/create-table-builder.js';
+export * from './schema/create-type-builder.js';
 export * from './schema/drop-table-builder.js';
+export * from './schema/drop-type-builder.js';
 export * from './schema/create-index-builder.js';
 export * from './schema/drop-index-builder.js';
 export * from './schema/create-schema-builder.js';
@@ -87,6 +89,7 @@ export * from './operation-node/constraint-node.js';
 export * from './operation-node/create-index-node.js';
 export * from './operation-node/create-schema-node.js';
 export * from './operation-node/create-table-node.js';
+export * from './operation-node/create-type-node.js';
 export * from './operation-node/create-view-node.js';
 export * from './operation-node/data-type-node.js';
 export * from './operation-node/default-value-node.js';
@@ -96,6 +99,7 @@ export * from './operation-node/drop-constraint-node.js';
 export * from './operation-node/drop-index-node.js';
 export * from './operation-node/drop-schema-node.js';
 export * from './operation-node/drop-table-node.js';
+export * from './operation-node/drop-type-node.js';
 export * from './operation-node/drop-view-node.js';
 export * from './operation-node/filter-node.js';
 export * from './operation-node/foreign-key-constraint-node.js';

package/dist/cjs/index.js

@@ -41,7 +41,9 @@ __exportStar(require("./query-compiler/default-query-compiler.js"), exports);
 __exportStar(require("./query-compiler/compiled-query.js"), exports);
 __exportStar(require("./schema/schema.js"), exports);
 __exportStar(require("./schema/create-table-builder.js"), exports);
+__exportStar(require("./schema/create-type-builder.js"), exports);
 __exportStar(require("./schema/drop-table-builder.js"), exports);
+__exportStar(require("./schema/drop-type-builder.js"), exports);
 __exportStar(require("./schema/create-index-builder.js"), exports);
 __exportStar(require("./schema/drop-index-builder.js"), exports);
 __exportStar(require("./schema/create-schema-builder.js"), exports);
@@ -103,6 +105,7 @@ __exportStar(require("./operation-node/constraint-node.js"), exports);
 __exportStar(require("./operation-node/create-index-node.js"), exports);
 __exportStar(require("./operation-node/create-schema-node.js"), exports);
 __exportStar(require("./operation-node/create-table-node.js"), exports);
+__exportStar(require("./operation-node/create-type-node.js"), exports);
 __exportStar(require("./operation-node/create-view-node.js"), exports);
 __exportStar(require("./operation-node/data-type-node.js"), exports);
 __exportStar(require("./operation-node/default-value-node.js"), exports);
@@ -112,6 +115,7 @@ __exportStar(require("./operation-node/drop-constraint-node.js"), exports);
 __exportStar(require("./operation-node/drop-index-node.js"), exports);
 __exportStar(require("./operation-node/drop-schema-node.js"), exports);
 __exportStar(require("./operation-node/drop-table-node.js"), exports);
+__exportStar(require("./operation-node/drop-type-node.js"), exports);
 __exportStar(require("./operation-node/drop-view-node.js"), exports);
 __exportStar(require("./operation-node/filter-node.js"), exports);
 __exportStar(require("./operation-node/foreign-key-constraint-node.js"), exports);

package/dist/cjs/operation-node/create-type-node.d.ts

@@ -0,0 +1,17 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { ValueListNode } from './value-list-node.js';
+export declare type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
+export interface CreateTypeNode extends OperationNode {
+    readonly kind: 'CreateTypeNode';
+    readonly name: IdentifierNode;
+    readonly enum?: ValueListNode;
+}
+/**
+ * @internal
+ */
+export declare const CreateTypeNode: Readonly<{
+    is(node: OperationNode): node is CreateTypeNode;
+    create(name: string): CreateTypeNode;
+    cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
+}>;

package/dist/cjs/operation-node/create-type-node.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTypeNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+const value_list_node_js_1 = require("./value-list-node.js");
+const value_node_js_1 = require("./value-node.js");
+/**
+ * @internal
+ */
+exports.CreateTypeNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CreateTypeNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CreateTypeNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWithEnum(createType, values) {
+        return (0, object_utils_js_1.freeze)({
+            ...createType,
+            enum: value_list_node_js_1.ValueListNode.create(values.map((value) => value_node_js_1.ValueNode.createImmediate(value))),
+        });
+    },
+});

package/dist/cjs/operation-node/data-type-node.d.ts

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | 'time' | 'timetz' | 'timestamp' | 'timestamptz' | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
+export declare type ColumnDataType = 'varchar' | `varchar(${number})` | 'text' | 'integer' | 'int2' | 'int4' | 'int8' | 'bigint' | 'boolean' | 'real' | 'double precision' | 'float4' | 'float8' | 'decimal' | `decimal(${number}, ${number})` | 'numeric' | `numeric(${number}, ${number})` | 'binary' | 'date' | 'datetime' | `datetime(${number})` | 'time' | `time(${number})` | 'timetz' | `timetz(${number})` | 'timestamp' | `timestamp(${number})` | 'timestamptz' | `timestamptz(${number})` | 'serial' | 'bigserial' | 'uuid' | 'json' | 'jsonb' | 'blob';
 export declare type DataTypeParams = Omit<DataTypeNode, 'kind' | 'dataType'>;
 export interface DataTypeNode extends OperationNode {
     readonly kind: 'DataTypeNode';

package/dist/cjs/operation-node/drop-type-node.d.ts

@@ -0,0 +1,16 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export declare type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
+export interface DropTypeNode extends OperationNode {
+    readonly kind: 'DropTypeNode';
+    readonly name: IdentifierNode;
+    readonly ifExists?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropTypeNode: Readonly<{
+    is(node: OperationNode): node is DropTypeNode;
+    create(name: string): DropTypeNode;
+    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
+}>;

package/dist/cjs/operation-node/drop-type-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropTypeNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.DropTypeNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DropTypeNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DropTypeNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropType, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropType,
+            ...params,
+        });
+    },
+});

package/dist/cjs/operation-node/insert-query-node.d.ts

@@ -19,12 +19,13 @@ export interface InsertQueryNode extends OperationNode {
     readonly onDuplicateKey?: OnDuplicateKeyNode;
     readonly with?: WithNode;
     readonly ignore?: boolean;
+    readonly replace?: boolean;
 }
 /**
  * @internal
  */
 export declare const InsertQueryNode: Readonly<{
     is(node: OperationNode): node is InsertQueryNode;
-    create(into: TableNode, withNode?: WithNode): InsertQueryNode;
+    create(into: TableNode, withNode?: WithNode, replace?: boolean): InsertQueryNode;
     cloneWith(insertQuery: InsertQueryNode, props: InsertQueryNodeProps): InsertQueryNode;
 }>;

package/dist/cjs/operation-node/insert-query-node.js

@@ -9,11 +9,12 @@ exports.InsertQueryNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'InsertQueryNode';
     },
-    create(into, withNode) {
+    create(into, withNode, replace) {
         return (0, object_utils_js_1.freeze)({
             kind: 'InsertQueryNode',
             into,
             ...(withNode && { with: withNode }),
+            replace,
         });
     },
     cloneWith(insertQuery, props) {

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

@@ -65,6 +65,9 @@ import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
+import { SelectModifierNode } from './select-modifier-node.js';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -97,8 +100,9 @@ import { ValuesNode } from './values-node.js';
 export declare class OperationNodeTransformer {
     #private;
     protected readonly nodeStack: OperationNode[];
-    readonly transformNode: <T extends OperationNode | undefined>(node: OperationNode | undefined) => T;
-    protected transformNodeList<T extends OperationNode>(list: readonly T[] | undefined): readonly T[];
+    readonly transformNode: <T extends OperationNode | undefined, U extends T | undefined = T>(node: U) => T;
+    protected transformNodeList<T extends OperationNode, U extends T = T>(list: readonly U[]): readonly T[];
+    protected transformNodeList<T extends OperationNode, U extends T = T>(list: readonly U[] | undefined): readonly T[] | undefined;
     protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;
     protected transformSelection(node: SelectionNode): SelectionNode;
     protected transformColumn(node: ColumnNode): ColumnNode;
@@ -159,6 +163,9 @@ export declare class OperationNodeTransformer {
     protected transformGenerated(node: GeneratedNode): GeneratedNode;
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
+    protected transformSelectModifier(node: SelectModifierNode): SelectModifierNode;
+    protected transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;