feat(pg): add virtual generated columns support

- Add virtual mode support for PostgreSQL generated columns
- Update schema serializer to handle both virtual and stored generated columns
- Modify SQL generator to support VIRTUAL keyword in generated column statements
- Add comprehensive tests for virtual generated columns
- Update type definitions and interfaces for virtual generated column configuration
- Ensure backward compatibility with existing stored generated columns

drizzle-kit/src/serializer/pgSchema.ts

@@ -183,7 +183,7 @@ const column = object({
 	uniqueName: string().optional(),
 	nullsNotDistinct: boolean().optional(),
 	generated: object({
-		type: literal('stored'),
+		type: enumType(['virtual', 'stored']),
 		as: string(),
 	}).optional(),
 	identity: sequenceSchema
@@ -207,7 +207,7 @@ const columnSquashed = object({
 	uniqueName: string().optional(),
 	nullsNotDistinct: boolean().optional(),
 	generated: object({
-		type: literal('stored'),
+		type: enumType(['virtual', 'stored']),
 		as: string(),
 	}).optional(),
 	identity: string().optional(),

drizzle-kit/src/serializer/pgSerializer.ts

@@ -192,7 +192,7 @@ export const generatePgSnapshot = (
 							: typeof generated.as === 'function'
 							? dialect.sqlToQuery(generated.as() as SQL).sql
 							: (generated.as as any),
-						type: 'stored',
+						type: generated.mode ?? 'stored',
 					}
 					: undefined,
 				identity: identity
@@ -780,7 +780,7 @@ export const generatePgSnapshot = (
 								: typeof generated.as === 'function'
 								? dialect.sqlToQuery(generated.as() as SQL).sql
 								: (generated.as as any),
-							type: 'stored',
+							type: generated.mode ?? 'stored',
 						}
 						: undefined,
 					identity: identity

drizzle-kit/src/sqlgenerator.ts

@@ -413,7 +413,9 @@ class PgCreateTableConvertor extends Convertor {
 			const type = parseType(schemaPrefix, column.type);
 			const generated = column.generated;
 
-			const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
+			const generatedStatement = generated
+				? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}`
+				: '';
 
 			const unsquashedIdentity = column.identity
 				? PgSquasher.unsquashIdentity(column.identity)
@@ -1793,7 +1795,9 @@ class PgAlterTableAddColumnConvertor extends Convertor {
 			})`
 			: '';
 
-		const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : '';
+		const generatedStatement = generated
+			? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}`
+			: '';
 
 		return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN "${name}" ${fixedType}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${identityStatement};`;
 	}

drizzle-kit/tests/pg-generated.test.ts

@@ -527,3 +527,229 @@ test('generated as string: change generated constraint', async () => {
 		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
 	]);
 });
+
+test('generated as callback: add column with virtual generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
+
+	expect(statements).toStrictEqual([
+		{
+			column: {
+				generated: {
+					as: '"users"."name" || \'hello\'',
+					type: 'virtual',
+				},
+				name: 'gen_name',
+				notNull: false,
+				primaryKey: false,
+				type: 'text',
+			},
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_add_column',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS (\"users\".\"name\" || 'hello') VIRTUAL;`,
+	]);
+});
+
+test('generated as SQL: add column with virtual generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`concat("users"."name", 'hello')`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
+
+	expect(statements).toStrictEqual([
+		{
+			column: {
+				generated: {
+					as: 'concat("users"."name", \'hello\')',
+					type: 'virtual',
+				},
+				name: 'gen_name',
+				notNull: false,
+				primaryKey: false,
+				type: 'text',
+			},
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_add_column',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS (concat("users"."name", 'hello')) VIRTUAL;`,
+	]);
+});
+
+test('generated as string: add column with virtual generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`\"users\".\"name\" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
+
+	expect(statements).toStrictEqual([
+		{
+			column: {
+				generated: {
+					as: '"users"."name" || \'hello\'',
+					type: 'virtual',
+				},
+				name: 'gen_name',
+				notNull: false,
+				primaryKey: false,
+				type: 'text',
+			},
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_add_column',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		`ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || 'hello') VIRTUAL;`,
+	]);
+});
+
+test('change from stored to virtual generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: undefined,
+			columnDefault: undefined,
+			columnGenerated: { as: '"users"."name" || \'hello\'', type: 'virtual' },
+			columnName: 'gen_name',
+			columnNotNull: false,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_alter_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE "users" drop column "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+test('change from virtual to stored generated constraint', async () => {
+	const from = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: pgTable('users', {
+			id: integer('id'),
+			id2: integer('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemas(from, to, []);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: undefined,
+			columnDefault: undefined,
+			columnGenerated: { as: '"users"."name" || \'hello\'', type: 'stored' },
+			columnName: 'gen_name',
+			columnNotNull: false,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_alter_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE "users" drop column "gen_name";',
+		'ALTER TABLE "users" ADD COLUMN "gen_name" text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED;',
+	]);
+});

drizzle-orm/src/pg-core/columns/common.ts

@@ -30,6 +30,10 @@ export interface ReferenceConfig {
 	};
 }
 
+export interface PgGeneratedColumnConfig {
+	mode?: 'virtual' | 'stored';
+}
+
 export interface PgColumnBuilderBase<
 	T extends ColumnBuilderBaseConfig<ColumnDataType, string> = ColumnBuilderBaseConfig<ColumnDataType, string>,
 	TTypeConfig extends object = object,
@@ -83,13 +87,13 @@ export abstract class PgColumnBuilder<
 		return this;
 	}
 
-	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL)): HasGenerated<this, {
+	generatedAlwaysAs(as: SQL | T['data'] | (() => SQL), config?: PgGeneratedColumnConfig): HasGenerated<this, {
 		type: 'always';
 	}> {
 		this.config.generated = {
 			as,
 			type: 'always',
-			mode: 'stored',
+			mode: config?.mode ?? 'stored',
 		};
 		return this as HasGenerated<this, {
 			type: 'always';