kysely 0.13.0 → 0.14.0

package/dist/esm/query-builder/on-conflict-builder.js

@@ -0,0 +1,317 @@
+import { ColumnNode } from '../operation-node/column-node.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
+import { OnConflictNode } from '../operation-node/on-conflict-node.js';
+import { parseWhereFilter, parseReferenceFilter, parseExistFilter, parseNotExistFilter, } from '../parser/filter-parser.js';
+import { parseUpdateObject, } from '../parser/update-set-parser.js';
+import { freeze } from '../util/object-utils.js';
+import { preventAwait } from '../util/prevent-await.js';
+export class OnConflictBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    /**
+     * Specify a single column as the conflict target.
+     *
+     * Also see the {@link columns}, {@link constraint} and {@link expression}
+     * methods for alternative ways to specify the conflict target.
+     */
+    column(column) {
+        const columnNode = ColumnNode.create(column);
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                columns: this.#props.onConflictNode.columns
+                    ? freeze([...this.#props.onConflictNode.columns, columnNode])
+                    : freeze([columnNode]),
+            }),
+        });
+    }
+    /**
+     * Specify a list of columns as the conflict target.
+     *
+     * Also see the {@link column}, {@link constraint} and {@link expression}
+     * methods for alternative ways to specify the conflict target.
+     */
+    columns(columns) {
+        const columnNodes = columns.map(ColumnNode.create);
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                columns: this.#props.onConflictNode.columns
+                    ? freeze([...this.#props.onConflictNode.columns, ...columnNodes])
+                    : freeze(columnNodes),
+            }),
+        });
+    }
+    /**
+     * Specify a specific constraint by name as the conflict target.
+     *
+     * Also see the {@link column}, {@link columns} and {@link expression}
+     * methods for alternative ways to specify the conflict target.
+     */
+    constraint(constraintName) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                constraint: IdentifierNode.create(constraintName),
+            }),
+        });
+    }
+    /**
+     * Specify an expression as the conflict target.
+     *
+     * This can be used if the unique index is an expression index.
+     *
+     * Also see the {@link column}, {@link columns} and {@link constraint}
+     * methods for alternative ways to specify the conflict target.
+     */
+    expression(expression) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                indexExpression: expression.toOperationNode(),
+            }),
+        });
+    }
+    where(...args) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseWhereFilter(this.#props.parseContext, args)),
+        });
+    }
+    /**
+     * Specify an index predicate for the index target.
+     *
+     * See {@link WhereInterface.whereRef} for more info.
+     */
+    whereRef(lhs, op, rhs) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    orWhere(...args) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseWhereFilter(this.#props.parseContext, args)),
+        });
+    }
+    /**
+     * Specify an index predicate for the index target.
+     *
+     * See {@link WhereInterface.orWhereRef} for more info.
+     */
+    orWhereRef(lhs, op, rhs) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    /**
+     * Specify an index predicate for the index target.
+     *
+     * See {@link WhereInterface.whereExists} for more info.
+     */
+    whereExists(arg) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    /**
+     * Specify an index predicate for the index target.
+     *
+     * See {@link WhereInterface.whereNotExists} for more info.
+     */
+    whereNotExists(arg) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithIndexWhere(this.#props.onConflictNode, parseNotExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    /**
+     * Specify an index predicate for the index target.
+     *
+     * See {@link WhereInterface.orWhereExists} for more info.
+     */
+    orWhereExists(arg) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    /**
+     * Specify an index predicate for the index target.
+     *
+     * See {@link WhereInterface.orWhereNotExists} for more info.
+     */
+    orWhereNotExists(arg) {
+        return new OnConflictBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithIndexOrWhere(this.#props.onConflictNode, parseNotExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    /**
+     * Adds the "do nothing" conflict action.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db
+     *   .insertInto('person')
+     *   .values({ id: db.generated, first_name, pic })
+     *   .onConflict((oc) => oc
+     *     .column('pic')
+     *     .doNothing()
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "pic")
+     * values ($1, $2)
+     * on conflict ("pic") do nothing
+     * ```
+     */
+    doNothing() {
+        return new OnConflictDoNothingBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                doNothing: true,
+            }),
+        });
+    }
+    /**
+     * Adds the "do update set" conflict action.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db
+     *   .insertInto('person')
+     *   .values({ id: db.generated, first_name, pic })
+     *   .onConflict((oc) => oc
+     *     .column('pic')
+     *     .doUpdateSet({ first_name })
+     *   )
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * insert into "person" ("first_name", "pic")
+     * values ($1, $2)
+     * on conflict ("pic")
+     * do update set "first_name" = $3
+     * ```
+     */
+    doUpdateSet(updates) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {
+                updates: parseUpdateObject(this.#props.parseContext, updates),
+            }),
+        });
+    }
+}
+preventAwait(OnConflictBuilder, "don't await OnConflictBuilder instances.");
+export class OnConflictDoNothingBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    toOperationNode() {
+        return this.#props.onConflictNode;
+    }
+}
+preventAwait(OnConflictDoNothingBuilder, "don't await OnConflictDoNothingBuilder instances.");
+export class OnConflictUpdateBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    where(...args) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseWhereFilter(this.#props.parseContext, args)),
+        });
+    }
+    /**
+     * Specify a where condition for the update operation.
+     *
+     * See {@link WhereInterface.whereRef} for more info.
+     */
+    whereRef(lhs, op, rhs) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    orWhere(...args) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseWhereFilter(this.#props.parseContext, args)),
+        });
+    }
+    /**
+     * Specify a where condition for the update operation.
+     *
+     * See {@link WhereInterface.orWhereRef} for more info.
+     */
+    orWhereRef(lhs, op, rhs) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseReferenceFilter(this.#props.parseContext, lhs, op, rhs)),
+        });
+    }
+    /**
+     * Specify a where condition for the update operation.
+     *
+     * See {@link WhereInterface.whereExists} for more info.
+     */
+    whereExists(arg) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    /**
+     * Specify a where condition for the update operation.
+     *
+     * See {@link WhereInterface.whereNotExists} for more info.
+     */
+    whereNotExists(arg) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithUpdateWhere(this.#props.onConflictNode, parseNotExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    /**
+     * Specify a where condition for the update operation.
+     *
+     * See {@link WhereInterface.orWhereExists} for more info.
+     */
+    orWhereExists(arg) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    /**
+     * Specify a where condition for the update operation.
+     *
+     * See {@link WhereInterface.orWhereNotExists} for more info.
+     */
+    orWhereNotExists(arg) {
+        return new OnConflictUpdateBuilder({
+            ...this.#props,
+            onConflictNode: OnConflictNode.cloneWithUpdateOrWhere(this.#props.onConflictNode, parseNotExistFilter(this.#props.parseContext, arg)),
+        });
+    }
+    toOperationNode() {
+        return this.#props.onConflictNode;
+    }
+}
+preventAwait(OnConflictUpdateBuilder, "don't await OnConflictUpdateBuilder instances.");

package/dist/esm/query-compiler/default-query-compiler.d.ts

@@ -64,7 +64,7 @@ import { ColumnNode } from '../operation-node/column-node.js';
 import { UnionNode } from '../operation-node/union-node.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
-import { GeneratedAlwaysAsNode } from '../operation-node/generated-always-as-node.js';
+import { GeneratedNode } from '../operation-node/generated-node.js';
 import { DefaultValueNode } from '../operation-node/default-value-node.js';
 import { OnNode } from '../operation-node/on-node.js';
 import { ValuesNode } from '../operation-node/values-node.js';
@@ -142,7 +142,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitUnion(node: UnionNode): void;
     protected visitCreateView(node: CreateViewNode): void;
     protected visitDropView(node: DropViewNode): void;
-    protected visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
+    protected visitGenerated(node: GeneratedNode): void;
     protected visitDefaultValue(node: DefaultValueNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;

package/dist/esm/query-compiler/default-query-compiler.js

@@ -324,9 +324,9 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         if (node.unsigned) {
             this.append(' unsigned');
         }
-        if (node.generatedAlwaysAs) {
+        if (node.generated) {
             this.append(' ');
-            this.visitNode(node.generatedAlwaysAs);
+            this.visitNode(node.generated);
         }
         if (node.defaultTo) {
             this.append(' ');
@@ -451,16 +451,29 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
             this.compileList(node.columns);
             this.append(')');
         }
-        if (node.constraint) {
+        else if (node.constraint) {
             this.append(' on constraint ');
             this.visitNode(node.constraint);
         }
+        else if (node.indexExpression) {
+            this.append(' (');
+            this.visitNode(node.indexExpression);
+            this.append(')');
+        }
+        if (node.indexWhere) {
+            this.append(' ');
+            this.visitNode(node.indexWhere);
+        }
         if (node.doNothing === true) {
             this.append(' do nothing');
         }
         else if (node.updates) {
             this.append(' do update set ');
             this.compileList(node.updates);
+            if (node.updateWhere) {
+                this.append(' ');
+                this.visitNode(node.updateWhere);
+            }
         }
     }
     visitOnDuplicateKey(node) {
@@ -722,10 +735,23 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         this.visitNode(node.name);
     }
-    visitGeneratedAlwaysAs(node) {
-        this.append('generated always as (');
-        this.visitNode(node.expression);
-        this.append(')');
+    visitGenerated(node) {
+        this.append('generated ');
+        if (node.always) {
+            this.append('always ');
+        }
+        if (node.byDefault) {
+            this.append('by default ');
+        }
+        this.append('as ');
+        if (node.identity) {
+            this.append('identity');
+        }
+        if (node.expression) {
+            this.append('(');
+            this.visitNode(node.expression);
+            this.append(')');
+        }
         if (node.stored) {
             this.append(' stored');
         }

package/dist/esm/schema/alter-table-builder.d.ts

@@ -31,7 +31,7 @@ export declare class AlterTableBuilder {
      */
     modifyColumn(columnName: string, dataType: DataTypeExpression): AlterTableModifyColumnBuilder;
     addUniqueConstraint(constraintName: string, columns: string[]): AlterTableExecutor;
-    addCheckConstraint(constraintName: string, checkExpression: string): AlterTableExecutor;
+    addCheckConstraint(constraintName: string, checkExpression: AnyRawBuilder): AlterTableExecutor;
     addForeignKeyConstraint(constraintName: string, columns: string[], targetTable: string, targetColumns: string[]): AlterTableAddForeignKeyConstraintBuilder;
 }
 export interface AlterTableBuilderProps {
@@ -151,11 +151,13 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      * ```ts
      * db.schema
      *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(db.raw('number_of_legs < 5'))
+     *   )
      *   .execute()
      * ```
      */
-    check(sql: string): AlterTableAddColumnBuilder;
+    check(expression: AnyRawBuilder): AlterTableAddColumnBuilder;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
@@ -165,12 +167,20 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
      *   )
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder;
+    generatedAlwaysAs(expression: AnyRawBuilder): AlterTableAddColumnBuilder;
+    /**
+     * Adds the `generated always as identity` specifier on supported dialects.
+     */
+    generatedAlwaysAsIdentity(): AlterTableAddColumnBuilder;
+    /**
+     * Adds the `generated by default as identity` specifier on supported dialects.
+     */
+    generatedByDefaultAsIdentity(): AlterTableAddColumnBuilder;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}
@@ -286,11 +296,13 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      * ```ts
      * db.schema
      *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(db.raw('number_of_legs < 5'))
+     *   )
      *   .execute()
      * ```
      */
-    check(sql: string): AlterTableModifyColumnBuilder;
+    check(expression: AnyRawBuilder): AlterTableModifyColumnBuilder;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
@@ -300,12 +312,20 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
      *   )
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder;
+    generatedAlwaysAs(expression: AnyRawBuilder): AlterTableModifyColumnBuilder;
+    /**
+     * Adds the `generated always as identity` specifier on supported dialects.
+     */
+    generatedAlwaysAsIdentity(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds the `generated by default as identity` specifier on supported dialects.
+     */
+    generatedByDefaultAsIdentity(): AlterTableModifyColumnBuilder;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}

package/dist/esm/schema/alter-table-builder.js

@@ -95,7 +95,7 @@ export class AlterTableBuilder {
         return new AlterTableExecutor({
             ...this.#props,
             alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
-                addConstraint: AddConstraintNode.create(CheckConstraintNode.create(checkExpression, constraintName)),
+                addConstraint: AddConstraintNode.create(CheckConstraintNode.create(checkExpression.toOperationNode(), constraintName)),
             }),
         });
     }
@@ -238,16 +238,28 @@ export class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.defaultTo(value),
         });
     }
-    check(sql) {
+    check(expression) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.check(sql),
+            columnBuilder: this.#props.columnBuilder.check(expression),
         });
     }
-    generatedAlwaysAs(sql) {
+    generatedAlwaysAs(expression) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(expression),
+        });
+    }
+    generatedAlwaysAsIdentity() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAsIdentity(),
+        });
+    }
+    generatedByDefaultAsIdentity() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedByDefaultAsIdentity(),
         });
     }
     stored() {
@@ -327,16 +339,28 @@ export class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.defaultTo(value),
         });
     }
-    check(sql) {
+    check(expression) {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.check(expression),
+        });
+    }
+    generatedAlwaysAs(expression) {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(expression),
+        });
+    }
+    generatedAlwaysAsIdentity() {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.check(sql),
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAsIdentity(),
         });
     }
-    generatedAlwaysAs(sql) {
+    generatedByDefaultAsIdentity() {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+            columnBuilder: this.#props.columnBuilder.generatedByDefaultAsIdentity(),
         });
     }
     stored() {

package/dist/esm/schema/column-definition-builder.d.ts

@@ -93,11 +93,13 @@ export interface ColumnDefinitionBuilderInterface {
      * ```ts
      * db.schema
      *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(db.raw('number_of_legs < 5'))
+     *   )
      *   .execute()
      * ```
      */
-    check(sql: string): ColumnDefinitionBuilderInterface;
+    check(expression: AnyRawBuilder): ColumnDefinitionBuilderInterface;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
@@ -107,12 +109,20 @@ export interface ColumnDefinitionBuilderInterface {
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
      *   )
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(sql: string): ColumnDefinitionBuilderInterface;
+    generatedAlwaysAs(expression: AnyRawBuilder): ColumnDefinitionBuilderInterface;
+    /**
+     * Adds the `generated always as identity` specifier on supported dialects.
+     */
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilderInterface;
+    /**
+     * Adds the `generated by default as identity` specifier on supported dialects.
+     */
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilderInterface;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}
@@ -222,11 +232,13 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      * ```ts
      * db.schema
      *   .createTable('pet')
-     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(db.raw('number_of_legs < 5'))
+     *   )
      *   .execute()
      * ```
      */
-    check(sql: string): ColumnDefinitionBuilder;
+    check(expression: AnyRawBuilder): ColumnDefinitionBuilder;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
@@ -236,12 +248,20 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
      * db.schema
      *   .createTable('person')
      *   .addColumn('full_name', 'varchar(255)',
-     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
      *   )
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(sql: string): ColumnDefinitionBuilder;
+    generatedAlwaysAs(expression: AnyRawBuilder): ColumnDefinitionBuilder;
+    /**
+     * Adds the `generated always as identity` specifier on supported dialects.
+     */
+    generatedAlwaysAsIdentity(): ColumnDefinitionBuilder;
+    /**
+     * Adds the `generated by default as identity` specifier on supported dialects.
+     */
+    generatedByDefaultAsIdentity(): ColumnDefinitionBuilder;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}