kysely 0.10.0 → 0.10.1

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RuntimeDriver = void 0;
+const performance_now_js_1 = require("../util/performance-now.js");
 /**
  * A small wrapper around {@link Driver} that makes sure the driver is
  * initialized before it is used, only initialized and destroyed
@@ -75,7 +76,7 @@ class RuntimeConnection {
         this.#log = log;
     }
     async executeQuery(compiledQuery) {
-        const startTime = process.hrtime.bigint();
+        const startTime = (0, performance_now_js_1.performanceNow)();
         try {
             return await this.#connection.executeQuery(compiledQuery);
         }
@@ -101,8 +102,6 @@ class RuntimeConnection {
         }));
     }
     #calculateDurationMillis(startTime) {
-        const endTime = process.hrtime.bigint();
-        const durationNanos = Number(endTime - startTime);
-        return durationNanos / 1_000_000;
+        return (0, performance_now_js_1.performanceNow)() - startTime;
     }
 }

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

@@ -1,10 +1,11 @@
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
+import { DefaultValueNode } from './default-value-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
-import { ValueNode } from './value-node.js';
 export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
 export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
@@ -16,8 +17,9 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly autoIncrement: boolean;
     readonly unique: boolean;
     readonly nullable: boolean;
-    readonly defaultTo?: ValueNode | RawNode;
+    readonly defaultTo?: DefaultValueNode;
     readonly check?: CheckConstraintNode;
+    readonly generatedAlwaysAs?: GeneratedAlwaysAsNode;
 }
 /**
  * @internal

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

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+import { ValueNode } from './value-node.js';
+export interface DefaultValueNode extends OperationNode {
+    readonly kind: 'DefaultValueNode';
+    readonly defaultValue: ValueNode | RawNode;
+}
+/**
+ * @internal
+ */
+export declare const DefaultValueNode: Readonly<{
+    is(node: OperationNode): node is DefaultValueNode;
+    create(defaultValue: ValueNode | RawNode): DefaultValueNode;
+}>;

package/dist/cjs/operation-node/default-value-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultValueNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.DefaultValueNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DefaultValueNode';
+    },
+    create(defaultValue) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DefaultValueNode',
+            defaultValue,
+        });
+    },
+});

package/dist/cjs/operation-node/generated-always-as-node.d.ts

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export declare type GeneratedAlwaysAsNodeParams = Omit<GeneratedAlwaysAsNode, 'kind' | 'expression'>;
+export interface GeneratedAlwaysAsNode extends OperationNode {
+    readonly kind: 'GeneratedAlwaysAsNode';
+    readonly expression: RawNode;
+    readonly stored?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const GeneratedAlwaysAsNode: Readonly<{
+    is(node: OperationNode): node is GeneratedAlwaysAsNode;
+    create(expression: string): GeneratedAlwaysAsNode;
+    cloneWith(node: GeneratedAlwaysAsNode, params: GeneratedAlwaysAsNodeParams): GeneratedAlwaysAsNode;
+}>;

package/dist/cjs/operation-node/generated-always-as-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratedAlwaysAsNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const raw_node_js_1 = require("./raw-node.js");
+/**
+ * @internal
+ */
+exports.GeneratedAlwaysAsNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'GeneratedAlwaysAsNode';
+    },
+    create(expression) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'GeneratedAlwaysAsNode',
+            expression: raw_node_js_1.RawNode.createWithSql(expression),
+        });
+    },
+    cloneWith(node, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...node,
+            ...params,
+        });
+    },
+});

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

@@ -60,6 +60,8 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { DefaultValueNode } from './default-value-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -149,6 +151,8 @@ export declare class OperationNodeTransformer {
     protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
+    protected transformGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): GeneratedAlwaysAsNode;
+    protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -33,7 +33,7 @@ const object_utils_js_1 = require("../util/object-utils.js");
  */
 class OperationNodeTransformer {
     nodeStack = [];
-    #transformers = {
+    #transformers = (0, object_utils_js_1.freeze)({
         AliasNode: this.transformAlias.bind(this),
         ColumnNode: this.transformColumn.bind(this),
         IdentifierNode: this.transformIdentifier.bind(this),
@@ -95,7 +95,9 @@ class OperationNodeTransformer {
         UnionNode: this.transformUnion.bind(this),
         CreateViewNode: this.transformCreateView.bind(this),
         DropViewNode: this.transformDropView.bind(this),
-    };
+        GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
+        DefaultValueNode: this.transformDefaultValue.bind(this),
+    });
     transformNode = (node) => {
         if (!node) {
             return undefined;
@@ -274,6 +276,7 @@ class OperationNodeTransformer {
             nullable: node.nullable,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
+            generatedAlwaysAs: this.transformNode(node.generatedAlwaysAs),
         };
     }
     transformAddColumn(node) {
@@ -538,6 +541,19 @@ class OperationNodeTransformer {
             materialized: node.materialized,
         };
     }
+    transformGeneratedAlwaysAs(node) {
+        return {
+            kind: 'GeneratedAlwaysAsNode',
+            expression: this.transformNode(node.expression),
+            stored: node.stored,
+        };
+    }
+    transformDefaultValue(node) {
+        return {
+            kind: 'DefaultValueNode',
+            defaultValue: this.transformNode(node.defaultValue),
+        };
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -60,6 +60,8 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { DefaultValueNode } from './default-value-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -125,4 +127,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitOperator(node: OperatorNode): void;
     protected abstract visitCreateView(node: CreateViewNode): void;
     protected abstract visitDropView(node: DropViewNode): void;
+    protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
+    protected abstract visitDefaultValue(node: DefaultValueNode): void;
 }

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationNodeVisitor = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
 class OperationNodeVisitor {
     nodeStack = [];
-    #visitors = {
+    #visitors = (0, object_utils_js_1.freeze)({
         AliasNode: this.visitAlias.bind(this),
         ColumnNode: this.visitColumn.bind(this),
         IdentifierNode: this.visitIdentifier.bind(this),
@@ -65,7 +66,9 @@ class OperationNodeVisitor {
         UnionNode: this.visitUnion.bind(this),
         CreateViewNode: this.visitCreateView.bind(this),
         DropViewNode: this.visitDropView.bind(this),
-    };
+        GeneratedAlwaysAsNode: this.visitGeneratedAlwaysAs.bind(this),
+        DefaultValueNode: this.visitDefaultValue.bind(this),
+    });
     visitNode = (node) => {
         this.nodeStack.push(node);
         this.#visitors[node.kind](node);

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -9,6 +9,6 @@ export interface RawNode extends OperationNode {
  */
 export declare const RawNode: Readonly<{
     is(node: OperationNode): node is RawNode;
-    create(sqlFragments: string[], params: ReadonlyArray<OperationNode>): RawNode;
+    create(sqlFragments: ReadonlyArray<string>, params: ReadonlyArray<OperationNode>): RawNode;
     createWithSql(sql: string): RawNode;
 }>;

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

@@ -64,6 +64,8 @@ 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 { DefaultValueNode } from '../operation-node/default-value-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -134,6 +136,8 @@ 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 visitDefaultValue(node: DefaultValueNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

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

@@ -302,8 +302,12 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.visitNode(node.column);
         this.append(' ');
         this.visitNode(node.dataType);
+        if (node.generatedAlwaysAs) {
+            this.append(' ');
+            this.visitNode(node.generatedAlwaysAs);
+        }
         if (node.defaultTo) {
-            this.append(' default ');
+            this.append(' ');
             this.visitNode(node.defaultTo);
         }
         if (!node.nullable) {
@@ -679,6 +683,18 @@ 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(')');
+        if (node.stored) {
+            this.append(' stored');
+        }
+    }
+    visitDefaultValue(node) {
+        this.append('default ');
+        this.visitNode(node.defaultValue);
+    }
     append(str) {
         this.#sql += str;
     }

package/dist/cjs/raw-builder/raw-builder.d.ts

@@ -41,5 +41,5 @@ export interface RawBuilderProps {
     readonly queryId: QueryId;
     readonly executor: QueryExecutor;
     readonly sql: string;
-    readonly parameters?: any;
+    readonly parameters?: ReadonlyArray<unknown>;
 }

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

@@ -72,6 +72,8 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
     notNull(): AlterTableAddColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
     check(sql: string): AlterTableAddColumnBuilder;
+    generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder;
+    stored(): AlterTableAddColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
@@ -91,6 +93,8 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
     notNull(): AlterTableModifyColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
     check(sql: string): AlterTableModifyColumnBuilder;
+    generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder;
+    stored(): AlterTableModifyColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

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

@@ -244,6 +244,18 @@ class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.check(sql),
         });
     }
+    generatedAlwaysAs(sql) {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+        });
+    }
+    stored() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.stored(),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
             addColumn: add_column_node_js_1.AddColumnNode.create(this.#props.columnBuilder.toOperationNode()),
@@ -316,6 +328,18 @@ class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.check(sql),
         });
     }
+    generatedAlwaysAs(sql) {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+        });
+    }
+    stored() {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.stored(),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(alter_table_node_js_1.AlterTableNode.cloneWith(this.#props.alterTableNode, {
             modifyColumn: modify_column_node_js_1.ModifyColumnNode.create(this.#props.columnBuilder.toOperationNode()),

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

@@ -40,10 +40,19 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
+     * @example
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
      */
     onDelete(onDelete: OnModifyForeignAction): R;
     /**
      * Adds an `on update` constraint for the foreign key column.
+     *
+     * @example
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
      */
     onUpdate(onUpdate: OnModifyForeignAction): R;
     /**
@@ -78,6 +87,36 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * ```
      */
     check(sql: string): R;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * @example
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
+    generatedAlwaysAs(sql: string): R;
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * @example
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
+    stored(): R;
 }
 export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface<ColumnDefinitionBuilder>, OperationNodeSource {
     #private;
@@ -91,5 +130,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
     notNull(): ColumnDefinitionBuilder;
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     check(sql: string): ColumnDefinitionBuilder;
+    generatedAlwaysAs(sql: string): ColumnDefinitionBuilder;
+    stored(): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }

package/dist/cjs/schema/column-definition-builder.js

@@ -9,6 +9,8 @@ const reference_parser_js_1 = require("../parser/reference-parser.js");
 const prevent_await_js_1 = require("../util/prevent-await.js");
 const column_definition_node_js_1 = require("../operation-node/column-definition-node.js");
 const default_value_parser_js_1 = require("../parser/default-value-parser.js");
+const generated_always_as_node_js_1 = require("../operation-node/generated-always-as-node.js");
+const default_value_node_js_1 = require("../operation-node/default-value-node.js");
 class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
@@ -55,7 +57,7 @@ class ColumnDefinitionBuilder {
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {
-            defaultTo: (0, default_value_parser_js_1.parseDefaultValueExpression)(value),
+            defaultTo: default_value_node_js_1.DefaultValueNode.create((0, default_value_parser_js_1.parseDefaultValueExpression)(value)),
         }));
     }
     check(sql) {
@@ -63,6 +65,21 @@ class ColumnDefinitionBuilder {
             check: check_constraint_node_js_1.CheckConstraintNode.create(sql),
         }));
     }
+    generatedAlwaysAs(sql) {
+        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {
+            generatedAlwaysAs: generated_always_as_node_js_1.GeneratedAlwaysAsNode.create(sql),
+        }));
+    }
+    stored() {
+        if (!this.#node.generatedAlwaysAs) {
+            throw new Error('stored() can only be called after generatedAlwaysAs');
+        }
+        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {
+            generatedAlwaysAs: generated_always_as_node_js_1.GeneratedAlwaysAsNode.cloneWith(this.#node.generatedAlwaysAs, {
+                stored: true,
+            }),
+        }));
+    }
     toOperationNode() {
         return this.#node;
     }

package/dist/cjs/schema/create-table-builder.d.ts

@@ -27,8 +27,8 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * await db.schema
      *   .createTable('person')
      *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+     *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
      *   .addColumn('parent_id', 'integer', (col) =>
@@ -37,11 +37,10 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```
      *
      * With this method, it's once again good to remember that Kysely just builds the query
-     * that's as close to the structure of your builder method calls as possible, and doesn't
-     * provide the same API for all databses. For example, some databases like older MySQL
-     * don't support `references` statement in the column definition. Instead foreign key
-     * constraints need to be defined in at the level of the `create table` query. See
-     * the next example:
+     * and doesn't provide the same API for all databses. For example, some databases like
+     * older MySQL don't support `references` statement in the column definition. Instead
+     * foreign key constraints need to be defined in at the level of the `create table`
+     * query. See the next example:
      *
      * @example
      * ```ts

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

@@ -41,8 +41,8 @@ class CreateTableBuilder {
      * await db.schema
      *   .createTable('person')
      *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+     *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
      *   .addColumn('parent_id', 'integer', (col) =>
@@ -51,11 +51,10 @@ class CreateTableBuilder {
      * ```
      *
      * With this method, it's once again good to remember that Kysely just builds the query
-     * that's as close to the structure of your builder method calls as possible, and doesn't
-     * provide the same API for all databses. For example, some databases like older MySQL
-     * don't support `references` statement in the column definition. Instead foreign key
-     * constraints need to be defined in at the level of the `create table` query. See
-     * the next example:
+     * and doesn't provide the same API for all databses. For example, some databases like
+     * older MySQL don't support `references` statement in the column definition. Instead
+     * foreign key constraints need to be defined in at the level of the `create table`
+     * query. See the next example:
      *
      * @example
      * ```ts

package/dist/cjs/util/performance-now.d.ts

@@ -0,0 +1 @@
+export declare function performanceNow(): number;

package/dist/cjs/util/performance-now.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.performanceNow = void 0;
+const object_utils_js_1 = require("./object-utils.js");
+function performanceNow() {
+    if (typeof performance !== 'undefined' && (0, object_utils_js_1.isFunction)(performance.now)) {
+        return performance.now();
+    }
+    else {
+        return Date.now();
+    }
+}
+exports.performanceNow = performanceNow;

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

@@ -1,3 +1,4 @@
+import { performanceNow } from '../util/performance-now.js';
 /**
  * A small wrapper around {@link Driver} that makes sure the driver is
  * initialized before it is used, only initialized and destroyed
@@ -71,7 +72,7 @@ class RuntimeConnection {
         this.#log = log;
     }
     async executeQuery(compiledQuery) {
-        const startTime = process.hrtime.bigint();
+        const startTime = performanceNow();
         try {
             return await this.#connection.executeQuery(compiledQuery);
         }
@@ -97,8 +98,6 @@ class RuntimeConnection {
         }));
     }
     #calculateDurationMillis(startTime) {
-        const endTime = process.hrtime.bigint();
-        const durationNanos = Number(endTime - startTime);
-        return durationNanos / 1_000_000;
+        return performanceNow() - startTime;
     }
 }

package/dist/esm/operation-node/column-definition-node.d.ts

@@ -1,10 +1,11 @@
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { ColumnNode } from './column-node.js';
 import { DataTypeNode } from './data-type-node.js';
+import { DefaultValueNode } from './default-value-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { OperationNode } from './operation-node.js';
 import { RawNode } from './raw-node.js';
 import { ReferencesNode } from './references-node.js';
-import { ValueNode } from './value-node.js';
 export declare type ColumnDefinitionNodeProps = Omit<Partial<ColumnDefinitionNode>, 'kind'>;
 export declare type ColumnDataTypeNode = DataTypeNode | RawNode;
 export interface ColumnDefinitionNode extends OperationNode {
@@ -16,8 +17,9 @@ export interface ColumnDefinitionNode extends OperationNode {
     readonly autoIncrement: boolean;
     readonly unique: boolean;
     readonly nullable: boolean;
-    readonly defaultTo?: ValueNode | RawNode;
+    readonly defaultTo?: DefaultValueNode;
     readonly check?: CheckConstraintNode;
+    readonly generatedAlwaysAs?: GeneratedAlwaysAsNode;
 }
 /**
  * @internal

package/dist/esm/operation-node/default-value-node.d.ts

@@ -0,0 +1,14 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+import { ValueNode } from './value-node.js';
+export interface DefaultValueNode extends OperationNode {
+    readonly kind: 'DefaultValueNode';
+    readonly defaultValue: ValueNode | RawNode;
+}
+/**
+ * @internal
+ */
+export declare const DefaultValueNode: Readonly<{
+    is(node: OperationNode): node is DefaultValueNode;
+    create(defaultValue: ValueNode | RawNode): DefaultValueNode;
+}>;

package/dist/esm/operation-node/default-value-node.js

@@ -0,0 +1,15 @@
+import { freeze } from '../util/object-utils.js';
+/**
+ * @internal
+ */
+export const DefaultValueNode = freeze({
+    is(node) {
+        return node.kind === 'DefaultValueNode';
+    },
+    create(defaultValue) {
+        return freeze({
+            kind: 'DefaultValueNode',
+            defaultValue,
+        });
+    },
+});

package/dist/esm/operation-node/generated-always-as-node.d.ts

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export declare type GeneratedAlwaysAsNodeParams = Omit<GeneratedAlwaysAsNode, 'kind' | 'expression'>;
+export interface GeneratedAlwaysAsNode extends OperationNode {
+    readonly kind: 'GeneratedAlwaysAsNode';
+    readonly expression: RawNode;
+    readonly stored?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const GeneratedAlwaysAsNode: Readonly<{
+    is(node: OperationNode): node is GeneratedAlwaysAsNode;
+    create(expression: string): GeneratedAlwaysAsNode;
+    cloneWith(node: GeneratedAlwaysAsNode, params: GeneratedAlwaysAsNodeParams): GeneratedAlwaysAsNode;
+}>;

package/dist/esm/operation-node/generated-always-as-node.js

@@ -0,0 +1,22 @@
+import { freeze } from '../util/object-utils.js';
+import { RawNode } from './raw-node.js';
+/**
+ * @internal
+ */
+export const GeneratedAlwaysAsNode = freeze({
+    is(node) {
+        return node.kind === 'GeneratedAlwaysAsNode';
+    },
+    create(expression) {
+        return freeze({
+            kind: 'GeneratedAlwaysAsNode',
+            expression: RawNode.createWithSql(expression),
+        });
+    },
+    cloneWith(node, params) {
+        return freeze({
+            ...node,
+            ...params,
+        });
+    },
+});

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

@@ -60,6 +60,8 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { DefaultValueNode } from './default-value-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -149,6 +151,8 @@ export declare class OperationNodeTransformer {
     protected transformDropConstraint(node: DropConstraintNode): DropConstraintNode;
     protected transformCreateView(node: CreateViewNode): CreateViewNode;
     protected transformDropView(node: DropViewNode): DropViewNode;
+    protected transformGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): GeneratedAlwaysAsNode;
+    protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

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

@@ -30,7 +30,7 @@ import { freeze } from '../util/object-utils.js';
  */
 export class OperationNodeTransformer {
     nodeStack = [];
-    #transformers = {
+    #transformers = freeze({
         AliasNode: this.transformAlias.bind(this),
         ColumnNode: this.transformColumn.bind(this),
         IdentifierNode: this.transformIdentifier.bind(this),
@@ -92,7 +92,9 @@ export class OperationNodeTransformer {
         UnionNode: this.transformUnion.bind(this),
         CreateViewNode: this.transformCreateView.bind(this),
         DropViewNode: this.transformDropView.bind(this),
-    };
+        GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
+        DefaultValueNode: this.transformDefaultValue.bind(this),
+    });
     transformNode = (node) => {
         if (!node) {
             return undefined;
@@ -271,6 +273,7 @@ export class OperationNodeTransformer {
             nullable: node.nullable,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
+            generatedAlwaysAs: this.transformNode(node.generatedAlwaysAs),
         };
     }
     transformAddColumn(node) {
@@ -535,6 +538,19 @@ export class OperationNodeTransformer {
             materialized: node.materialized,
         };
     }
+    transformGeneratedAlwaysAs(node) {
+        return {
+            kind: 'GeneratedAlwaysAsNode',
+            expression: this.transformNode(node.expression),
+            stored: node.stored,
+        };
+    }
+    transformDefaultValue(node) {
+        return {
+            kind: 'DefaultValueNode',
+            defaultValue: this.transformNode(node.defaultValue),
+        };
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

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

@@ -60,6 +60,8 @@ import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { UnionNode } from './union-node.js';
 import { CreateViewNode } from './create-view-node.js';
 import { DropViewNode } from './drop-view-node.js';
+import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
+import { DefaultValueNode } from './default-value-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -125,4 +127,6 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitOperator(node: OperatorNode): void;
     protected abstract visitCreateView(node: CreateViewNode): void;
     protected abstract visitDropView(node: DropViewNode): void;
+    protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
+    protected abstract visitDefaultValue(node: DefaultValueNode): void;
 }

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

@@ -1,6 +1,7 @@
+import { freeze } from '../util/object-utils.js';
 export class OperationNodeVisitor {
     nodeStack = [];
-    #visitors = {
+    #visitors = freeze({
         AliasNode: this.visitAlias.bind(this),
         ColumnNode: this.visitColumn.bind(this),
         IdentifierNode: this.visitIdentifier.bind(this),
@@ -62,7 +63,9 @@ export class OperationNodeVisitor {
         UnionNode: this.visitUnion.bind(this),
         CreateViewNode: this.visitCreateView.bind(this),
         DropViewNode: this.visitDropView.bind(this),
-    };
+        GeneratedAlwaysAsNode: this.visitGeneratedAlwaysAs.bind(this),
+        DefaultValueNode: this.visitDefaultValue.bind(this),
+    });
     visitNode = (node) => {
         this.nodeStack.push(node);
         this.#visitors[node.kind](node);

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -9,6 +9,6 @@ export interface RawNode extends OperationNode {
  */
 export declare const RawNode: Readonly<{
     is(node: OperationNode): node is RawNode;
-    create(sqlFragments: string[], params: ReadonlyArray<OperationNode>): RawNode;
+    create(sqlFragments: ReadonlyArray<string>, params: ReadonlyArray<OperationNode>): RawNode;
     createWithSql(sql: string): RawNode;
 }>;

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

@@ -64,6 +64,8 @@ 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 { DefaultValueNode } from '../operation-node/default-value-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -134,6 +136,8 @@ 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 visitDefaultValue(node: DefaultValueNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

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

@@ -299,8 +299,12 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         this.visitNode(node.column);
         this.append(' ');
         this.visitNode(node.dataType);
+        if (node.generatedAlwaysAs) {
+            this.append(' ');
+            this.visitNode(node.generatedAlwaysAs);
+        }
         if (node.defaultTo) {
-            this.append(' default ');
+            this.append(' ');
             this.visitNode(node.defaultTo);
         }
         if (!node.nullable) {
@@ -676,6 +680,18 @@ export class DefaultQueryCompiler extends OperationNodeVisitor {
         }
         this.visitNode(node.name);
     }
+    visitGeneratedAlwaysAs(node) {
+        this.append('generated always as (');
+        this.visitNode(node.expression);
+        this.append(')');
+        if (node.stored) {
+            this.append(' stored');
+        }
+    }
+    visitDefaultValue(node) {
+        this.append('default ');
+        this.visitNode(node.defaultValue);
+    }
     append(str) {
         this.#sql += str;
     }

package/dist/esm/raw-builder/raw-builder.d.ts

@@ -41,5 +41,5 @@ export interface RawBuilderProps {
     readonly queryId: QueryId;
     readonly executor: QueryExecutor;
     readonly sql: string;
-    readonly parameters?: any;
+    readonly parameters?: ReadonlyArray<unknown>;
 }

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

@@ -72,6 +72,8 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
     notNull(): AlterTableAddColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
     check(sql: string): AlterTableAddColumnBuilder;
+    generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder;
+    stored(): AlterTableAddColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;
@@ -91,6 +93,8 @@ export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBu
     notNull(): AlterTableModifyColumnBuilder;
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
     check(sql: string): AlterTableModifyColumnBuilder;
+    generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder;
+    stored(): AlterTableModifyColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
     execute(): Promise<void>;

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

@@ -238,6 +238,18 @@ export class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.check(sql),
         });
     }
+    generatedAlwaysAs(sql) {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+        });
+    }
+    stored() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.stored(),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(AlterTableNode.cloneWith(this.#props.alterTableNode, {
             addColumn: AddColumnNode.create(this.#props.columnBuilder.toOperationNode()),
@@ -309,6 +321,18 @@ export class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.check(sql),
         });
     }
+    generatedAlwaysAs(sql) {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+        });
+    }
+    stored() {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.stored(),
+        });
+    }
     toOperationNode() {
         return this.#props.executor.transformQuery(AlterTableNode.cloneWith(this.#props.alterTableNode, {
             modifyColumn: ModifyColumnNode.create(this.#props.columnBuilder.toOperationNode()),

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

@@ -40,10 +40,19 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
+     * @example
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
      */
     onDelete(onDelete: OnModifyForeignAction): R;
     /**
      * Adds an `on update` constraint for the foreign key column.
+     *
+     * @example
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
      */
     onUpdate(onUpdate: OnModifyForeignAction): R;
     /**
@@ -78,6 +87,36 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * ```
      */
     check(sql: string): R;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * @example
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
+    generatedAlwaysAs(sql: string): R;
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * @example
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
+    stored(): R;
 }
 export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface<ColumnDefinitionBuilder>, OperationNodeSource {
     #private;
@@ -91,5 +130,7 @@ export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderI
     notNull(): ColumnDefinitionBuilder;
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
     check(sql: string): ColumnDefinitionBuilder;
+    generatedAlwaysAs(sql: string): ColumnDefinitionBuilder;
+    stored(): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }

package/dist/esm/schema/column-definition-builder.js

@@ -6,6 +6,8 @@ import { parseStringReference } from '../parser/reference-parser.js';
 import { preventAwait } from '../util/prevent-await.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { parseDefaultValueExpression, } from '../parser/default-value-parser.js';
+import { GeneratedAlwaysAsNode } from '../operation-node/generated-always-as-node.js';
+import { DefaultValueNode } from '../operation-node/default-value-node.js';
 export class ColumnDefinitionBuilder {
     #node;
     constructor(node) {
@@ -52,7 +54,7 @@ export class ColumnDefinitionBuilder {
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
-            defaultTo: parseDefaultValueExpression(value),
+            defaultTo: DefaultValueNode.create(parseDefaultValueExpression(value)),
         }));
     }
     check(sql) {
@@ -60,6 +62,21 @@ export class ColumnDefinitionBuilder {
             check: CheckConstraintNode.create(sql),
         }));
     }
+    generatedAlwaysAs(sql) {
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            generatedAlwaysAs: GeneratedAlwaysAsNode.create(sql),
+        }));
+    }
+    stored() {
+        if (!this.#node.generatedAlwaysAs) {
+            throw new Error('stored() can only be called after generatedAlwaysAs');
+        }
+        return new ColumnDefinitionBuilder(ColumnDefinitionNode.cloneWith(this.#node, {
+            generatedAlwaysAs: GeneratedAlwaysAsNode.cloneWith(this.#node.generatedAlwaysAs, {
+                stored: true,
+            }),
+        }));
+    }
     toOperationNode() {
         return this.#node;
     }

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

@@ -27,8 +27,8 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * await db.schema
      *   .createTable('person')
      *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+     *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
      *   .addColumn('parent_id', 'integer', (col) =>
@@ -37,11 +37,10 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      * ```
      *
      * With this method, it's once again good to remember that Kysely just builds the query
-     * that's as close to the structure of your builder method calls as possible, and doesn't
-     * provide the same API for all databses. For example, some databases like older MySQL
-     * don't support `references` statement in the column definition. Instead foreign key
-     * constraints need to be defined in at the level of the `create table` query. See
-     * the next example:
+     * and doesn't provide the same API for all databses. For example, some databases like
+     * older MySQL don't support `references` statement in the column definition. Instead
+     * foreign key constraints need to be defined in at the level of the `create table`
+     * query. See the next example:
      *
      * @example
      * ```ts

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

@@ -38,8 +38,8 @@ export class CreateTableBuilder {
      * await db.schema
      *   .createTable('person')
      *   .addColumn('id', 'integer', (col) => col.autoIncrement().primaryKey()),
-     *   .addColumn('first_name', 'varchar(50), (col) => col.notNull())
-     *   .addColumn('last_name', 'varchar')
+     *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
+     *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
      *   .addColumn('data', db.raw('customtype'))
      *   .addColumn('parent_id', 'integer', (col) =>
@@ -48,11 +48,10 @@ export class CreateTableBuilder {
      * ```
      *
      * With this method, it's once again good to remember that Kysely just builds the query
-     * that's as close to the structure of your builder method calls as possible, and doesn't
-     * provide the same API for all databses. For example, some databases like older MySQL
-     * don't support `references` statement in the column definition. Instead foreign key
-     * constraints need to be defined in at the level of the `create table` query. See
-     * the next example:
+     * and doesn't provide the same API for all databses. For example, some databases like
+     * older MySQL don't support `references` statement in the column definition. Instead
+     * foreign key constraints need to be defined in at the level of the `create table`
+     * query. See the next example:
      *
      * @example
      * ```ts

package/dist/esm/util/performance-now.d.ts

@@ -0,0 +1 @@
+export declare function performanceNow(): number;

package/dist/esm/util/performance-now.js

@@ -0,0 +1,9 @@
+import { isFunction } from './object-utils.js';
+export function performanceNow() {
+    if (typeof performance !== 'undefined' && isFunction(performance.now)) {
+        return performance.now();
+    }
+    else {
+        return Date.now();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -47,9 +47,9 @@
     "mocha": "^9.1.3",
     "mysql2": "^2.3.3",
     "pg": "^8.7.1",
-    "prettier": "^2.4.1",
+    "prettier": "^2.5.1",
     "tsd": "^0.19.0",
-    "typedoc": "^0.22.9",
+    "typedoc": "^0.22.10",
     "typescript": "4.5.2"
   }
 }