kysely 0.12.0 → 0.14.0

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

@@ -324,15 +324,18 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.visitNode(node.column);
         this.append(' ');
         this.visitNode(node.dataType);
-        if (node.generatedAlwaysAs) {
+        if (node.unsigned) {
+            this.append(' unsigned');
+        }
+        if (node.generated) {
             this.append(' ');
-            this.visitNode(node.generatedAlwaysAs);
+            this.visitNode(node.generated);
         }
         if (node.defaultTo) {
             this.append(' ');
             this.visitNode(node.defaultTo);
         }
-        if (!node.nullable) {
+        if (node.notNull) {
             this.append(' not null');
         }
         if (node.unique) {
@@ -451,16 +454,29 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             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) {
@@ -573,6 +589,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
     }
     visitWith(node) {
         this.append('with ');
+        if (node.recursive) {
+            this.append('recursive ');
+        }
         this.compileList(node.expressions);
     }
     visitCommonTableExpression(node) {
@@ -580,6 +599,14 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.append(' as ');
         this.visitNode(node.expression);
     }
+    visitCommonTableExpressionName(node) {
+        this.visitNode(node.table);
+        if (node.columns) {
+            this.append('(');
+            this.compileList(node.columns);
+            this.append(')');
+        }
+    }
     visitAlterTable(node) {
         this.append('alter table ');
         this.visitNode(node.table);
@@ -711,10 +738,23 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         }
         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/cjs/query-creator.d.ts

@@ -5,7 +5,7 @@ import { UpdateQueryBuilder } from './query-builder/update-query-builder.js';
 import { TableExpression, TableExpressionDatabase, TableExpressionTables, TableReference } from './parser/table-parser.js';
 import { QueryExecutor } from './query-executor/query-executor.js';
 import { RawBuilder } from './raw-builder/raw-builder.js';
-import { CommonTableExpression, QueryCreatorWithCommonTableExpression } from './parser/with-parser.js';
+import { CommonTableExpression, QueryCreatorWithCommonTableExpression, RecursiveCommonTableExpression } from './parser/with-parser.js';
 import { WithNode } from './operation-node/with-node.js';
 import { ParseContext } from './parser/parse-context.js';
 import { InsertResult } from './query-builder/insert-result.js';
@@ -206,7 +206,7 @@ export declare class QueryCreator<DB> {
      */
     updateTable<TR extends TableReference<DB>>(table: TR): UpdateQueryBuilder<TableExpressionDatabase<DB, TR>, TableExpressionTables<DB, never, TR>, UpdateResult>;
     /**
-     * Creates a `with` query (common table expressions).
+     * Creates a `with` query (Common Table Expression).
      *
      * ### Examples
      *
@@ -227,8 +227,32 @@ export declare class QueryCreator<DB> {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The CTE name can optionally specify column names in addition to
+     * a name. In that case Kysely requires the expression to retun
+     * rows with the same columns.
+     *
+     * ```ts
+     * await db
+     *   .with('jennifers(id, age)', (db) => db
+     *     .selectFrom('person')
+     *     .where('first_name', '=', 'Jennifer')
+     *     // This is ok since we return columns with the same
+     *     // names as specified by `jennifers(id, age)`.
+     *     .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
+     */
+    with<N extends string, E extends CommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    /**
+     * Creates a recursive `with` query (Common Table Expression).
+     *
+     * See the {@link with} method for examples and more documentation.
      */
-    with<N extends string, E extends CommonTableExpression<DB>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
+    withRecursive<N extends string, E extends RecursiveCommonTableExpression<DB, N>>(name: N, expression: E): QueryCreatorWithCommonTableExpression<DB, N, E>;
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.

package/dist/cjs/query-creator.js

@@ -136,7 +136,7 @@ class QueryCreator {
         });
     }
     /**
-     * Creates a `with` query (common table expressions).
+     * Creates a `with` query (Common Table Expression).
      *
      * ### Examples
      *
@@ -157,6 +157,24 @@ class QueryCreator {
      *   .selectAll()
      *   .execute()
      * ```
+     *
+     * The CTE name can optionally specify column names in addition to
+     * a name. In that case Kysely requires the expression to retun
+     * rows with the same columns.
+     *
+     * ```ts
+     * await db
+     *   .with('jennifers(id, age)', (db) => db
+     *     .selectFrom('person')
+     *     .where('first_name', '=', 'Jennifer')
+     *     // This is ok since we return columns with the same
+     *     // names as specified by `jennifers(id, age)`.
+     *     .select(['id', 'age'])
+     *   )
+     *   .selectFrom('jennifers')
+     *   .selectAll()
+     *   .execute()
+     * ```
      */
     with(name, expression) {
         const cte = (0, with_parser_js_1.parseCommonTableExpression)(this.#props.parseContext, name, expression);
@@ -167,6 +185,20 @@ class QueryCreator {
                 : with_node_js_1.WithNode.create(cte),
         });
     }
+    /**
+     * Creates a recursive `with` query (Common Table Expression).
+     *
+     * See the {@link with} method for examples and more documentation.
+     */
+    withRecursive(name, expression) {
+        const cte = (0, with_parser_js_1.parseCommonTableExpression)(this.#props.parseContext, name, expression);
+        return new QueryCreator({
+            ...this.#props,
+            withNode: this.#props.withNode
+                ? with_node_js_1.WithNode.cloneWithExpression(this.#props.withNode, cte)
+                : with_node_js_1.WithNode.create(cte, { recursive: true }),
+        });
+    }
     /**
      * Sets the schema to be used for all table references that don't explicitly
      * specify a schema.

package/dist/cjs/query-executor/default-query-executor.d.ts

@@ -7,10 +7,29 @@ import { QueryExecutor } from './query-executor.js';
 export declare class DefaultQueryExecutor extends QueryExecutor {
     #private;
     constructor(compiler: QueryCompiler, connectionProvider: ConnectionProvider, plugins?: KyselyPlugin[]);
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
     compileQuery(node: RootOperationNode): CompiledQuery;
     protected executeQueryImpl<R>(compiledQuery: CompiledQuery): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
     withPlugin(plugin: KyselyPlugin): DefaultQueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
     withPluginAtFront(plugin: KyselyPlugin): DefaultQueryExecutor;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
     withConnectionProvider(connectionProvider: ConnectionProvider): QueryExecutor;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
     withoutPlugins(): QueryExecutor;
 }

package/dist/cjs/query-executor/noop-query-executor.d.ts

@@ -8,10 +8,29 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
  * other needed things to actually execute queries.
  */
 export declare class NoopQueryExecutor extends QueryExecutor {
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
     compileQuery(): CompiledQuery;
     protected executeQueryImpl<R>(): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
     withConnectionProvider(): QueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
     withPlugin(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
     withPluginAtFront(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
     withoutPlugins(): QueryExecutor;
 }

package/dist/cjs/raw-builder/raw-builder.js

@@ -50,7 +50,7 @@ class RawBuilder {
             if (match.index > 0 && sql[match.index - 1] === '\\') {
                 continue;
             }
-            sqlFragments.push(sql.slice(sqlIdx, match.index).replaceAll('\\?', '?'));
+            sqlFragments.push(sql.slice(sqlIdx, match.index).replace(/\\\?/g, '?'));
             argNodes.push(parseRawArg(str, parameters[paramIdx]));
             sqlIdx = match.index + str.length;
             ++paramIdx;

package/dist/cjs/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 {
@@ -63,16 +63,140 @@ export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableAddColumnBuilderProps);
+    /**
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
+     *
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
+     */
     autoIncrement(): AlterTableAddColumnBuilder;
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a foreign key constraint for the column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id')
+     * ```
+     */
     references(ref: string): AlterTableAddColumnBuilder;
+    /**
+     * Adds an `on delete` constraint for the foreign key column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
+     */
     onDelete(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a default value constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+     *   .execute()
+     * ```
+     */
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
-    check(sql: string): AlterTableAddColumnBuilder;
-    generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(db.raw('number_of_legs < 5'))
+     *   )
+     *   .execute()
+     * ```
+     */
+    check(expression: AnyRawBuilder): AlterTableAddColumnBuilder;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
+     *   )
+     *   .execute()
+     * ```
+     */
+    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}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
     stored(): AlterTableAddColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
@@ -84,16 +208,140 @@ export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps
 export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableModifyColumnBuilderProps);
+    /**
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
+     *
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
+     */
     autoIncrement(): AlterTableModifyColumnBuilder;
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a foreign key constraint for the column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id')
+     * ```
+     */
     references(ref: string): AlterTableModifyColumnBuilder;
+    /**
+     * Adds an `on delete` constraint for the foreign key column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
+     */
     onDelete(onDelete: OnModifyForeignAction): AlterTableModifyColumnBuilder;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onUpdate: OnModifyForeignAction): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a default value constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+     *   .execute()
+     * ```
+     */
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
-    check(sql: string): AlterTableModifyColumnBuilder;
-    generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) =>
+     *     col.check(db.raw('number_of_legs < 5'))
+     *   )
+     *   .execute()
+     * ```
+     */
+    check(expression: AnyRawBuilder): AlterTableModifyColumnBuilder;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
+     *   )
+     *   .execute()
+     * ```
+     */
+    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}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
     stored(): AlterTableModifyColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;

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

@@ -98,7 +98,7 @@ class AlterTableBuilder {
         return new AlterTableExecutor({
             ...this.#props,
             alterTableNode: alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
-                addConstraint: add_constraint_node_js_1.AddConstraintNode.create(check_constraint_node_js_1.CheckConstraintNode.create(checkExpression, constraintName)),
+                addConstraint: add_constraint_node_js_1.AddConstraintNode.create(check_constraint_node_js_1.CheckConstraintNode.create(checkExpression.toOperationNode(), constraintName)),
             }),
         });
     }
@@ -232,22 +232,40 @@ class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.notNull(),
         });
     }
+    unsigned() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.unsigned(),
+        });
+    }
     defaultTo(value) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
             columnBuilder: this.#props.columnBuilder.defaultTo(value),
         });
     }
-    check(sql) {
+    check(expression) {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.check(expression),
+        });
+    }
+    generatedAlwaysAs(expression) {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(expression),
+        });
+    }
+    generatedAlwaysAsIdentity() {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.check(sql),
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAsIdentity(),
         });
     }
-    generatedAlwaysAs(sql) {
+    generatedByDefaultAsIdentity() {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
-            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+            columnBuilder: this.#props.columnBuilder.generatedByDefaultAsIdentity(),
         });
     }
     stored() {
@@ -316,22 +334,40 @@ class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.notNull(),
         });
     }
+    unsigned() {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.unsigned(),
+        });
+    }
     defaultTo(value) {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,
             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() {