@anthonyalayo/drizzle-kit 1.0.1

package/tests/sqlite-generated.test.ts

@@ -0,0 +1,1726 @@
+// 1. add stored column to existing table - not supported +
+// 2. add virtual column to existing table - supported +
+// 3. create table with stored/virtual columns(pg, mysql, sqlite)
+// 4. add stored generated to column -> not supported +
+// 5. add virtual generated to column -> supported with drop+add column +
+// 6. drop stored/virtual expression -> supported with drop+add column
+// 7. alter generated expession -> stored not supported, virtual supported
+
+import { SQL, sql } from 'drizzle-orm';
+import { int, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+import { expect, test } from 'vitest';
+import { diffTestSchemasSqlite } from './schemaDiffer';
+
+// should generate 0 statements + warning/error in console
+test('generated as callback: add column with stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as callback: add column with virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			column: {
+				generated: {
+					as: '("name" || \'hello\')',
+					type: 'virtual',
+				},
+				autoincrement: false,
+				name: 'gen_name',
+				notNull: false,
+				primaryKey: false,
+				type: 'text',
+			},
+			referenceData: undefined,
+			tableName: 'users',
+			type: 'sqlite_alter_table_add_column',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as callback: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs((): SQL => sql`${from.users.name} || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: {
+				as: '("name" || \'to add\')',
+				type: 'virtual',
+			},
+			columnName: 'gen_name',
+			columnNotNull: true,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_set_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("name" || \'to add\') VIRTUAL NOT NULL;',
+	]);
+});
+
+test('generated as callback: drop generated constraint as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: undefined,
+			columnName: 'gen_name',
+			columnNotNull: false,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_drop_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+test('generated as callback: drop generated constraint as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name} || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: undefined,
+			columnName: 'gen_name',
+			columnNotNull: false,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_drop_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+// no way to do it
+test('generated as callback: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as callback: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: {
+				as: '("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 `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+// not supported
+test('generated as callback: change stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as callback: change virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${from.users.name}`,
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: {
+				as: '("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 `gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+test('generated as callback: add table with column with stored generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columns: [
+				{
+					autoincrement: false,
+					name: 'id',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'id2',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+				{
+					autoincrement: false,
+					generated: {
+						as: '("name" || \'hello\')',
+						type: 'stored',
+					},
+					name: 'gen_name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+			],
+			compositePKs: [],
+			referenceData: [],
+			tableName: 'users',
+			type: 'sqlite_create_table',
+			uniqueConstraints: [],
+			checkConstraints: [],
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') STORED\n);\n',
+	]);
+});
+
+test('generated as callback: add table with column with virtual generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				(): SQL => sql`${to.users.name} || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columns: [
+				{
+					autoincrement: false,
+					name: 'id',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'id2',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+				{
+					autoincrement: false,
+					generated: {
+						as: '("name" || \'hello\')',
+						type: 'virtual',
+					},
+					name: 'gen_name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+			],
+			compositePKs: [],
+			referenceData: [],
+			tableName: 'users',
+			type: 'sqlite_create_table',
+			uniqueConstraints: [],
+			checkConstraints: [],
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("name" || \'hello\') VIRTUAL\n);\n',
+	]);
+});
+
+// ---
+
+test('generated as sql: add column with stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || \'hello\' || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as sql: add column with virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || \'hello\'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			column: {
+				generated: {
+					as: '("users"."name" || \'hello\')',
+					type: 'virtual',
+				},
+				autoincrement: false,
+				name: 'gen_name',
+				notNull: false,
+				primaryKey: false,
+				type: 'text',
+			},
+			referenceData: undefined,
+			tableName: 'users',
+			type: 'sqlite_alter_table_add_column',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`"users"."name" || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as sql: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(sql`"users"."name" || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: {
+				as: '("users"."name" || \'to add\')',
+				type: 'virtual',
+			},
+			columnName: 'gen_name',
+			columnNotNull: true,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_set_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'to add\') VIRTUAL NOT NULL;',
+	]);
+});
+
+test('generated as sql: drop generated constraint as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: undefined,
+			columnName: 'gen_name',
+			columnNotNull: false,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_drop_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+test('generated as sql: drop generated constraint as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: undefined,
+			columnName: 'gen_name',
+			columnNotNull: false,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_drop_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+// no way to do it
+test('generated as sql: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"users"."name"`, {
+				mode: 'virtual',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as sql: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"users"."name"`, {
+				mode: 'stored',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			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 `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+// not supported
+test('generated as sql: change stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"users"."name"`, {
+				mode: 'stored',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as sql: change virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(sql`"users"."name"`),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			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 `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+test('generated as sql: add table with column with stored generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columns: [
+				{
+					autoincrement: false,
+					name: 'id',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'id2',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+				{
+					autoincrement: false,
+					generated: {
+						as: '("users"."name" || \'hello\')',
+						type: 'stored',
+					},
+					name: 'gen_name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+			],
+			compositePKs: [],
+			referenceData: [],
+			tableName: 'users',
+			type: 'sqlite_create_table',
+			uniqueConstraints: [],
+			checkConstraints: [],
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED\n);\n',
+	]);
+});
+
+test('generated as sql: add table with column with virtual generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				sql`"users"."name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columns: [
+				{
+					autoincrement: false,
+					name: 'id',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'id2',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+				{
+					autoincrement: false,
+					generated: {
+						as: '("users"."name" || \'hello\')',
+						type: 'virtual',
+					},
+					name: 'gen_name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+			],
+			compositePKs: [],
+			referenceData: [],
+			tableName: 'users',
+			type: 'sqlite_create_table',
+			uniqueConstraints: [],
+			checkConstraints: [],
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL\n);\n',
+	]);
+});
+
+// ---
+
+test('generated as string: add column with stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || \'hello\'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as string: add column with virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || \'hello\'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			column: {
+				generated: {
+					as: '("users"."name" || \'hello\')',
+					type: 'virtual',
+				},
+				autoincrement: false,
+				name: 'gen_name',
+				notNull: false,
+				primaryKey: false,
+				type: 'text',
+			},
+			referenceData: undefined,
+			tableName: 'users',
+			type: 'sqlite_alter_table_add_column',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+test('generated as string: add generated constraint to an exisiting column as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(`"users"."name" || 'to add'`, {
+					mode: 'stored',
+				}),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as string: add generated constraint to an exisiting column as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').notNull(),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name')
+				.notNull()
+				.generatedAlwaysAs(`"users"."name" || 'to add'`, {
+					mode: 'virtual',
+				}),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: {
+				as: '("users"."name" || \'to add\')',
+				type: 'virtual',
+			},
+			columnName: 'gen_name',
+			columnNotNull: true,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_set_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'to add\') VIRTUAL NOT NULL;',
+	]);
+});
+
+test('generated as string: drop generated constraint as stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || 'to delete'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: undefined,
+			columnName: 'gen_name',
+			columnNotNull: false,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_drop_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+test('generated as string: drop generated constraint as virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || 'to delete'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName1: text('gen_name'),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			columnDefault: undefined,
+			columnGenerated: undefined,
+			columnName: 'gen_name',
+			columnNotNull: false,
+			columnOnUpdate: undefined,
+			columnPk: false,
+			newDataType: 'text',
+			schema: '',
+			tableName: 'users',
+			type: 'alter_table_alter_column_drop_generated',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `users` DROP COLUMN `gen_name`;',
+		'ALTER TABLE `users` ADD `gen_name` text;',
+	]);
+});
+
+// no way to do it
+test('generated as string: change generated constraint type from virtual to stored', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(`"users"."name"`, {
+				mode: 'virtual',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as string: change generated constraint type from stored to virtual', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(`"users"."name"`, {
+				mode: 'stored',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			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 `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+// not supported
+test('generated as string: change stored generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(`"users"."name"`, {
+				mode: 'stored',
+			}),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+});
+
+test('generated as string: change virtual generated constraint', async () => {
+	const from = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(`"users"."name"`),
+		}),
+	};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || 'hello'`,
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columnAutoIncrement: false,
+			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 `gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL;',
+	]);
+});
+
+test('generated as string: add table with column with stored generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || 'hello'`,
+				{ mode: 'stored' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columns: [
+				{
+					autoincrement: false,
+					name: 'id',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'id2',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+				{
+					autoincrement: false,
+					generated: {
+						as: '("users"."name" || \'hello\')',
+						type: 'stored',
+					},
+					name: 'gen_name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+			],
+			compositePKs: [],
+			referenceData: [],
+			tableName: 'users',
+			type: 'sqlite_create_table',
+			uniqueConstraints: [],
+			checkConstraints: [],
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') STORED\n);\n',
+	]);
+});
+
+test('generated as string: add table with column with virtual generated constraint', async () => {
+	const from = {};
+	const to = {
+		users: sqliteTable('users', {
+			id: int('id'),
+			id2: int('id2'),
+			name: text('name'),
+			generatedName: text('gen_name').generatedAlwaysAs(
+				`"users"."name" || 'hello'`,
+				{ mode: 'virtual' },
+			),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasSqlite(
+		from,
+		to,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			columns: [
+				{
+					autoincrement: false,
+					name: 'id',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'id2',
+					notNull: false,
+					primaryKey: false,
+					type: 'integer',
+				},
+				{
+					autoincrement: false,
+					name: 'name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+				{
+					autoincrement: false,
+					generated: {
+						as: '("users"."name" || \'hello\')',
+						type: 'virtual',
+					},
+					name: 'gen_name',
+					notNull: false,
+					primaryKey: false,
+					type: 'text',
+				},
+			],
+			compositePKs: [],
+			referenceData: [],
+			tableName: 'users',
+			type: 'sqlite_create_table',
+			uniqueConstraints: [],
+			checkConstraints: [],
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `users` (\n\t`id` integer,\n\t`id2` integer,\n\t`name` text,\n\t`gen_name` text GENERATED ALWAYS AS ("users"."name" || \'hello\') VIRTUAL\n);\n',
+	]);
+});