kysely 0.23.2 → 0.23.4

package/README.md

@@ -207,37 +207,34 @@ among other places.
 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'
+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
+  // PostgresDialect requires the Cursor dependency
+  dialect: new PostgresDialect({
+    pool: new Pool({
+      host: 'localhost',
+      database: 'kysely_test'
     }),
-
-    // MysqlDialect doesn't require any special configuration
+    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;
-        }
+  for await (const adult of db.selectFrom('person')
+    .selectAll()
+    .where('age', '>', 18)
+    .stream()
+  ) {
+    console.log(`Hello ${adult.first_name}!`)
+
+    if (adult.first_name === 'John') {
+      // After this line the db connection is released and no more
+      // rows are streamed from the database to the client
+      break;
     }
+  }
 }
 ```
 
@@ -268,6 +265,7 @@ or "recipes" for common use cases.
 * [Extending kysely](https://github.com/koskimas/kysely/tree/master/recipes/extending-kysely.md)
 * [Raw SQL](https://github.com/koskimas/kysely/tree/master/recipes/raw-sql.md)
 * [Schemas](https://github.com/koskimas/kysely/tree/master/recipes/schemas.md)
+* [Dealing with the `Type instantiation is excessively deep and possibly infinite` error](https://github.com/koskimas/kysely/tree/master/recipes/excessively-deep-types.md)
 
 # Migrations
 

package/dist/cjs/dialect/dialect-adapter-base.d.ts

@@ -25,12 +25,38 @@ export declare abstract class DialectAdapterBase implements DialectAdapter {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

package/dist/cjs/dialect/dialect-adapter.d.ts

@@ -26,19 +26,45 @@ export interface DialectAdapter {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise
      * `db` is a single connection (session) that will be used to execute the
      * migrations.
      */
-    acquireMigrationLock(db: Kysely<any>): Promise<void>;
+    acquireMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
     /**
      * Releases the migration lock. See {@link acquireMigrationLock}.
      *
@@ -47,5 +73,21 @@ export interface DialectAdapter {
      * is a single connection (session) that was used to execute the migrations
      * and the `acquireMigrationLock` call.
      */
-    releaseMigrationLock(db: Kysely<any>): Promise<void>;
+    releaseMigrationLock(db: Kysely<any>, options: MigrationLockOptions): Promise<void>;
+}
+export interface MigrationLockOptions {
+    /**
+     * The name of the migration lock table.
+     */
+    readonly lockTable: string;
+    /**
+     * The id of the only row in the migration lock table.
+     */
+    readonly lockRowId: string;
+    /**
+     * The schema in which the migration lock table lives. This is only
+     * defined if the user has specified a custom schema in the migration
+     * settings.
+     */
+    readonly lockTableSchema?: string;
 }

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

@@ -19,12 +19,38 @@ export declare class MysqlAdapter extends DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -13,7 +13,7 @@ class MysqlIntrospector {
         let rawSchemas = await this.#db
             .selectFrom('information_schema.schemata')
             .select('schema_name')
-            .castTo()
+            .$castTo()
             .execute();
         return rawSchemas.map((it) => ({ name: it.SCHEMA_NAME }));
     }
@@ -31,8 +31,8 @@ class MysqlIntrospector {
         ])
             .where('table_schema', '=', (0, sql_js_1.sql) `database()`)
             .orderBy('table_name')
-            .orderBy('column_name')
-            .castTo();
+            .orderBy('ordinal_position')
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('table_name', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)

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

@@ -19,12 +19,38 @@ export declare class PostgresAdapter extends DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -13,7 +13,7 @@ class PostgresIntrospector {
         let rawSchemas = await this.#db
             .selectFrom('pg_catalog.pg_namespace')
             .select('nspname')
-            .castTo()
+            .$castTo()
             .execute();
         return rawSchemas.map((it) => ({ name: it.nspname }));
     }
@@ -57,8 +57,8 @@ class PostgresIntrospector {
             .where('a.attisdropped', '!=', true)
             .orderBy('ns.nspname')
             .orderBy('c.relname')
-            .orderBy('a.attname')
-            .castTo();
+            .orderBy('a.attnum')
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('c.relname', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)

package/dist/cjs/dialect/sqlite/sqlite-adapter.d.ts

@@ -18,12 +18,38 @@ export declare class SqliteAdapter implements DialectAdapterBase {
      * Most dialects have explicit locks that can be used, like advisory locks
      * in PostgreSQL and the get_lock function in MySQL.
      *
-     * If the dialect doesn't have explicit locks the {@link MIGRATION_LOCK_TABLE}
-     * created by Kysely can be used instead. {@link MIGRATION_LOCK_TABLE}
-     * has two columns `id` and `is_locked` and there's only one row in the
-     * table whose id is {@link MIGRATION_LOCK_ID}. `is_locked` is an integer.
-     * Kysely takes care of creating the lock table and inserting the one single
-     * row to it before this method is executed.
+     * If the dialect doesn't have explicit locks the {@link MigrationLockOptions.lockTable}
+     * created by Kysely can be used instead. You can access it through the `options` object.
+     * The lock table has two columns `id` and `is_locked` and there's only one row in the table
+     * whose id is {@link MigrationLockOptions.lockRowId}. `is_locked` is an integer. Kysely
+     * takes care of creating the lock table and inserting the one single row to it before this
+     * method is executed. If the dialect supports schemas and the user has specified a custom
+     * schema in their migration settings, the options object also contains the schema name in
+     * {@link MigrationLockOptions.lockTableSchema}.
+     *
+     * Here's an example of how you might implement this method for a dialect that doesn't
+     * have explicit locks but supports `FOR UPDATE` row locks and transactional DDL:
+     *
+     * ```ts
+     * {
+     *   async acquireMigrationLock(db, options): Promise<void> {
+     *     const queryDb = options.lockTableSchema
+     *       ? db.withSchema(options.lockTableSchema)
+     *       : db
+     *
+     *     // Since our imaginary dialect supports transactional DDL and has
+     *     // row locks, we can simply take a row lock here and it will guarantee
+     *     // all subsequent calls to this method from other transactions will
+     *     // wait until this transaction finishes.
+     *     await queryDb
+     *       .selectFrom(options.lockTable)
+     *       .selectAll()
+     *       .where('id', '=', options.lockRowId)
+     *       .forUpdate()
+     *       .execute()
+     *   }
+     * }
+     * ```
      *
      * If `supportsTransactionalDdl` is `true` then the `db` passed to this method
      * is a transaction inside which the migrations will be executed. Otherwise

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

@@ -19,7 +19,7 @@ class SqliteIntrospector {
             .where('name', 'not like', 'sqlite_%')
             .select('name')
             .orderBy('name')
-            .castTo();
+            .$castTo();
         if (!options.withInternalKyselyTables) {
             query = query
                 .where('name', '!=', migrator_js_1.DEFAULT_MIGRATION_TABLE)
@@ -40,7 +40,7 @@ class SqliteIntrospector {
             .selectFrom('sqlite_master')
             .where('name', '=', table)
             .select('sql')
-            .castTo()
+            .$castTo()
             .execute();
         // Try to find the name of the column that has `autoincrement` 🤦
         const autoIncrementCol = createSql[0]?.sql
@@ -52,7 +52,7 @@ class SqliteIntrospector {
         const columns = await db
             .selectFrom((0, sql_js_1.sql) `pragma_table_info(${table})`.as('table_info'))
             .select(['name', 'type', 'notnull', 'dflt_value'])
-            .orderBy('name')
+            .orderBy('cid')
             .execute();
         return {
             name: table,

package/dist/cjs/index.d.ts

@@ -159,6 +159,7 @@ export * from './operation-node/partition-by-item-node.js';
 export * from './operation-node/set-operation-node.js';
 export * from './operation-node/binary-operation-node.js';
 export * from './operation-node/unary-operation-node.js';
+export * from './operation-node/using-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';
@@ -172,7 +173,7 @@ export { ValueExpression, ValueExpressionOrList, } from './parser/value-parser.j
 export { TableExpression, TableExpressionOrList, } from './parser/table-parser.js';
 export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-parser.js';
 export { InsertObject } from './parser/insert-values-parser.js';
-export { MutationObject } from './parser/update-set-parser.js';
+export { UpdateObject } from './parser/update-set-parser.js';
 export { OrderByExpression, OrderByDirectionExpression, } from './parser/order-by-parser.js';
 export { ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList, } from './parser/binary-operation-parser.js';
 export { ExistsExpression } from './parser/unary-operation-parser.js';

package/dist/cjs/index.js

@@ -176,6 +176,7 @@ __exportStar(require("./operation-node/partition-by-item-node.js"), exports);
 __exportStar(require("./operation-node/set-operation-node.js"), exports);
 __exportStar(require("./operation-node/binary-operation-node.js"), exports);
 __exportStar(require("./operation-node/unary-operation-node.js"), exports);
+__exportStar(require("./operation-node/using-node.js"), exports);
 __exportStar(require("./util/column-type.js"), exports);
 __exportStar(require("./util/compilable.js"), exports);
 __exportStar(require("./util/explainable.js"), exports);

package/dist/cjs/migration/migrator.d.ts

@@ -24,12 +24,17 @@ export interface Migration {
  * other way.
  *
  * ```ts
+ * import { promises as fs } from 'fs'
+ * import path from 'path'
+ *
  * const migrator = new Migrator({
  *   db,
- *   provider: new FileMigrationProvider(
+ *   provider: new FileMigrationProvider({
+ *     fs,
+ *     path,
  *     // Path to the folder that contains all your migrations.
- *     'some/path/to/migrations'
- *   )
+ *     migrationFolder: 'some/path/to/migrations'
+ *   })
  * })
  * ```
  */

package/dist/cjs/migration/migrator.js

@@ -19,12 +19,17 @@ exports.NO_MIGRATIONS = (0, object_utils_js_1.freeze)({ __noMigrations__: true }
  * other way.
  *
  * ```ts
+ * import { promises as fs } from 'fs'
+ * import path from 'path'
+ *
  * const migrator = new Migrator({
  *   db,
- *   provider: new FileMigrationProvider(
+ *   provider: new FileMigrationProvider({
+ *     fs,
+ *     path,
  *     // Path to the folder that contains all your migrations.
- *     'some/path/to/migrations'
- *   )
+ *     migrationFolder: 'some/path/to/migrations'
+ *   })
  * })
  * ```
  */
@@ -318,9 +323,14 @@ class Migrator {
     }
     async #runMigrations(getTargetMigrationIndex) {
         const adapter = this.#props.db.getExecutor().adapter;
+        const lockOptions = (0, object_utils_js_1.freeze)({
+            lockTable: this.#props.migrationLockTableName ?? exports.DEFAULT_MIGRATION_LOCK_TABLE,
+            lockRowId: exports.MIGRATION_LOCK_ID,
+            lockTableSchema: this.#props.migrationTableSchema,
+        });
         const run = async (db) => {
             try {
-                await adapter.acquireMigrationLock(db);
+                await adapter.acquireMigrationLock(db, lockOptions);
                 const state = await this.#getState(db);
                 if (state.migrations.length === 0) {
                     return { results: [] };
@@ -338,7 +348,7 @@ class Migrator {
                 return { results: [] };
             }
             finally {
-                await adapter.releaseMigrationLock(db);
+                await adapter.releaseMigrationLock(db, lockOptions);
             }
         };
         if (adapter.supportsTransactionalDdl) {

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

@@ -11,6 +11,7 @@ export interface CreateIndexNode extends OperationNode {
     readonly expression?: OperationNode;
     readonly unique?: boolean;
     readonly using?: RawNode;
+    readonly ifNotExists?: boolean;
 }
 /**
  * @internal

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

@@ -8,9 +8,11 @@ import { LimitNode } from './limit-node.js';
 import { OrderByNode } from './order-by-node.js';
 import { OrderByItemNode } from './order-by-item-node.js';
 import { ExplainNode } from './explain-node.js';
+import { UsingNode } from './using-node.js';
 export interface DeleteQueryNode extends OperationNode {
     readonly kind: 'DeleteQueryNode';
     readonly from: FromNode;
+    readonly using?: UsingNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
     readonly returning?: ReturningNode;
@@ -28,4 +30,5 @@ export declare const DeleteQueryNode: Readonly<{
     cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithExplain(deleteNode: DeleteQueryNode, explain: ExplainNode): DeleteQueryNode;
+    cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

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

@@ -4,6 +4,7 @@ exports.DeleteQueryNode = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 const from_node_js_1 = require("./from-node.js");
 const order_by_node_js_1 = require("./order-by-node.js");
+const using_node_js_1 = require("./using-node.js");
 /**
  * @internal
  */
@@ -38,4 +39,12 @@ exports.DeleteQueryNode = (0, object_utils_js_1.freeze)({
             explain,
         });
     },
+    cloneWithUsing(deleteNode, tables) {
+        return (0, object_utils_js_1.freeze)({
+            ...deleteNode,
+            using: deleteNode.using !== undefined
+                ? using_node_js_1.UsingNode.cloneWithTables(deleteNode.using, tables)
+                : using_node_js_1.UsingNode.create(tables),
+        });
+    },
 });

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

@@ -76,6 +76,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
+import { UsingNode } from './using-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -181,6 +182,7 @@ export declare class OperationNodeTransformer {
     protected transformPartitionByItem(node: PartitionByItemNode): PartitionByItemNode;
     protected transformBinaryOperation(node: BinaryOperationNode): BinaryOperationNode;
     protected transformUnaryOperation(node: UnaryOperationNode): UnaryOperationNode;
+    protected transformUsing(node: UsingNode): UsingNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -112,6 +112,7 @@ class OperationNodeTransformer {
         SetOperationNode: this.transformSetOperation.bind(this),
         BinaryOperationNode: this.transformBinaryOperation.bind(this),
         UnaryOperationNode: this.transformUnaryOperation.bind(this),
+        UsingNode: this.transformUsing.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -261,6 +262,7 @@ class OperationNodeTransformer {
         return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DeleteQueryNode',
             from: this.transformNode(node.from),
+            using: this.transformNode(node.using),
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             returning: this.transformNode(node.returning),
@@ -404,6 +406,7 @@ class OperationNodeTransformer {
             expression: this.transformNode(node.expression),
             unique: node.unique,
             using: this.transformNode(node.using),
+            ifNotExists: node.ifNotExists,
         });
     }
     transformList(node) {
@@ -689,6 +692,12 @@ class OperationNodeTransformer {
             operand: this.transformNode(node.operand),
         });
     }
+    transformUsing(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'UsingNode',
+            tables: node.tables,
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -76,6 +76,7 @@ import { PartitionByItemNode } from './partition-by-item-node.js';
 import { SetOperationNode } from './set-operation-node.js';
 import { BinaryOperationNode } from './binary-operation-node.js';
 import { UnaryOperationNode } from './unary-operation-node.js';
+import { UsingNode } from './using-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -158,4 +159,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitSetOperation(node: SetOperationNode): void;
     protected abstract visitBinaryOperation(node: BinaryOperationNode): void;
     protected abstract visitUnaryOperation(node: UnaryOperationNode): void;
+    protected abstract visitUsing(node: UsingNode): void;
 }

package/dist/cjs/operation-node/operation-node-visitor.js

@@ -85,6 +85,7 @@ class OperationNodeVisitor {
         SetOperationNode: this.visitSetOperation.bind(this),
         BinaryOperationNode: this.visitBinaryOperation.bind(this),
         UnaryOperationNode: this.visitUnaryOperation.bind(this),
+        UsingNode: this.visitUsing.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -1,5 +1,5 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "&&", "||", "@@", "@@@", "!!", "<->"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "&&", "||", "@@", "@@@", "!!", "<->"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare type ComparisonOperator = typeof COMPARISON_OPERATORS[number];
 export declare type UnaryFilterOperator = typeof UNARY_FILTER_OPERATORS[number];