@anthonyalayo/drizzle-kit 1.0.1

package/tests/push/sqlite.test.ts

@@ -0,0 +1,1613 @@
+import Database from 'better-sqlite3';
+import chalk from 'chalk';
+import { sql } from 'drizzle-orm';
+import {
+	blob,
+	check,
+	foreignKey,
+	getTableConfig,
+	int,
+	integer,
+	numeric,
+	primaryKey,
+	real,
+	sqliteTable,
+	sqliteView,
+	text,
+	uniqueIndex,
+} from 'drizzle-orm/sqlite-core';
+import { diffTestSchemasPushSqlite, introspectSQLiteToFile } from 'tests/schemaDiffer';
+import { expect, test } from 'vitest';
+
+test('nothing changed in schema', async (t) => {
+	const client = new Database(':memory:');
+
+	const users = sqliteTable('users', {
+		id: integer('id').primaryKey().notNull(),
+		name: text('name').notNull(),
+		email: text('email'),
+		textJson: text('text_json', { mode: 'json' }),
+		blobJon: blob('blob_json', { mode: 'json' }),
+		blobBigInt: blob('blob_bigint', { mode: 'bigint' }),
+		numeric: numeric('numeric'),
+		createdAt: integer('created_at', { mode: 'timestamp' }),
+		createdAtMs: integer('created_at_ms', { mode: 'timestamp_ms' }),
+		real: real('real'),
+		text: text('text', { length: 255 }),
+		role: text('role', { enum: ['admin', 'user'] }).default('user'),
+		isConfirmed: integer('is_confirmed', {
+			mode: 'boolean',
+		}),
+	});
+
+	const schema1 = {
+		users,
+
+		customers: sqliteTable('customers', {
+			id: integer('id').primaryKey(),
+			address: text('address').notNull(),
+			isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
+			registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
+				.notNull()
+				.$defaultFn(() => new Date()),
+			userId: integer('user_id')
+				.references(() => users.id)
+				.notNull(),
+		}),
+
+		posts: sqliteTable('posts', {
+			id: integer('id').primaryKey(),
+			content: text('content'),
+			authorId: integer('author_id'),
+		}),
+	};
+
+	const {
+		sqlStatements,
+		statements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(client, schema1, schema1, [], false);
+
+	expect(sqlStatements.length).toBe(0);
+	expect(statements.length).toBe(0);
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+});
+
+test('dropped, added unique index', async (t) => {
+	const client = new Database(':memory:');
+
+	const users = sqliteTable('users', {
+		id: integer('id').primaryKey().notNull(),
+		name: text('name').notNull(),
+		email: text('email'),
+		textJson: text('text_json', { mode: 'json' }),
+		blobJon: blob('blob_json', { mode: 'json' }),
+		blobBigInt: blob('blob_bigint', { mode: 'bigint' }),
+		numeric: numeric('numeric'),
+		createdAt: integer('created_at', { mode: 'timestamp' }),
+		createdAtMs: integer('created_at_ms', { mode: 'timestamp_ms' }),
+		real: real('real'),
+		text: text('text', { length: 255 }),
+		role: text('role', { enum: ['admin', 'user'] }).default('user'),
+		isConfirmed: integer('is_confirmed', {
+			mode: 'boolean',
+		}),
+	});
+
+	const schema1 = {
+		users,
+
+		customers: sqliteTable(
+			'customers',
+			{
+				id: integer('id').primaryKey(),
+				address: text('address').notNull().unique(),
+				isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
+				registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
+					.notNull()
+					.$defaultFn(() => new Date()),
+				userId: integer('user_id').notNull(),
+			},
+			(table) => ({
+				uniqueIndex: uniqueIndex('customers_address_unique').on(table.address),
+			}),
+		),
+
+		posts: sqliteTable('posts', {
+			id: integer('id').primaryKey(),
+			content: text('content'),
+			authorId: integer('author_id'),
+		}),
+	};
+
+	const schema2 = {
+		users,
+
+		customers: sqliteTable(
+			'customers',
+			{
+				id: integer('id').primaryKey(),
+				address: text('address').notNull(),
+				isConfirmed: integer('is_confirmed', { mode: 'boolean' }),
+				registrationDate: integer('registration_date', { mode: 'timestamp_ms' })
+					.notNull()
+					.$defaultFn(() => new Date()),
+				userId: integer('user_id').notNull(),
+			},
+			(table) => ({
+				uniqueIndex: uniqueIndex('customers_is_confirmed_unique').on(
+					table.isConfirmed,
+				),
+			}),
+		),
+
+		posts: sqliteTable('posts', {
+			id: integer('id').primaryKey(),
+			content: text('content'),
+			authorId: integer('author_id'),
+		}),
+	};
+
+	const {
+		sqlStatements,
+		statements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(client, schema1, schema2, [], false);
+	expect(statements.length).toBe(2);
+	expect(statements[0]).toStrictEqual({
+		type: 'drop_index',
+		tableName: 'customers',
+		data: 'customers_address_unique;address;true;',
+		schema: '',
+	});
+	expect(statements[1]).toStrictEqual({
+		type: 'create_index',
+		tableName: 'customers',
+		data: 'customers_is_confirmed_unique;is_confirmed;true;',
+		schema: '',
+		internal: {
+			indexes: {},
+		},
+	});
+
+	expect(sqlStatements.length).toBe(2);
+	expect(sqlStatements[0]).toBe(
+		`DROP INDEX \`customers_address_unique\`;`,
+	);
+	expect(sqlStatements[1]).toBe(
+		`CREATE UNIQUE INDEX \`customers_is_confirmed_unique\` ON \`customers\` (\`is_confirmed\`);`,
+	);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('added column not null and without default to table with data', async (t) => {
+	const client = new Database(':memory:');
+
+	const schema1 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+			age: integer('age').notNull(),
+		}),
+	};
+
+	const table = getTableConfig(schema1.companies);
+	const seedStatements = [
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.name.name}") VALUES ('drizzle');`,
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.name.name}") VALUES ('turso');`,
+	];
+
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+		false,
+		seedStatements,
+	);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'sqlite_alter_table_add_column',
+		tableName: 'companies',
+		column: {
+			name: 'age',
+			type: 'integer',
+			primaryKey: false,
+			notNull: true,
+			autoincrement: false,
+		},
+		referenceData: undefined,
+	});
+	expect(sqlStatements.length).toBe(2);
+	expect(sqlStatements[0]).toBe(`delete from companies;`);
+	expect(sqlStatements[1]).toBe(
+		`ALTER TABLE \`companies\` ADD \`age\` integer NOT NULL;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(1);
+	expect(infoToPrint![0]).toBe(
+		`· You're about to add not-null ${
+			chalk.underline(
+				'age',
+			)
+		} column without default value, which contains 2 items`,
+	);
+	expect(shouldAskForApprove).toBe(true);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(1);
+	expect(tablesToTruncate![0]).toBe('companies');
+});
+
+test('added column not null and without default to table without data', async (t) => {
+	const turso = new Database(':memory:');
+
+	const schema1 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+		}),
+	};
+
+	const schema2 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey(),
+			name: text('name').notNull(),
+			age: integer('age').notNull(),
+		}),
+	};
+
+	const {
+		sqlStatements,
+		statements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(turso, schema1, schema2, [], false);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'sqlite_alter_table_add_column',
+		tableName: 'companies',
+		column: {
+			name: 'age',
+			type: 'integer',
+			primaryKey: false,
+			notNull: true,
+			autoincrement: false,
+		},
+		referenceData: undefined,
+	});
+
+	expect(sqlStatements.length).toBe(1);
+	expect(sqlStatements[0]).toBe(
+		`ALTER TABLE \`companies\` ADD \`age\` integer NOT NULL;`,
+	);
+
+	expect(infoToPrint!.length).toBe(0);
+	expect(columnsToRemove!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('drop autoincrement. drop column with data', async (t) => {
+	const turso = new Database(':memory:');
+
+	const schema1 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey({ autoIncrement: false }),
+		}),
+	};
+
+	const table = getTableConfig(schema1.companies);
+	const seedStatements = [
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (1, 'drizzle');`,
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (2, 'turso');`,
+	];
+
+	const {
+		sqlStatements,
+		statements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(
+		turso,
+		schema1,
+		schema2,
+		[],
+		false,
+		seedStatements,
+	);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'recreate_table',
+		tableName: 'companies',
+		columns: [
+			{
+				name: 'id',
+				type: 'integer',
+				autoincrement: false,
+				notNull: true,
+				primaryKey: true,
+				generated: undefined,
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		uniqueConstraints: [],
+		checkConstraints: [],
+	});
+
+	expect(sqlStatements.length).toBe(4);
+	expect(sqlStatements[0]).toBe(
+		`CREATE TABLE \`__new_companies\` (
+\t\`id\` integer PRIMARY KEY NOT NULL
+);\n`,
+	);
+	expect(sqlStatements[1]).toBe(
+		`INSERT INTO \`__new_companies\`("id") SELECT "id" FROM \`companies\`;`,
+	);
+	expect(sqlStatements[2]).toBe(`DROP TABLE \`companies\`;`);
+	expect(sqlStatements[3]).toBe(
+		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(1);
+	expect(columnsToRemove![0]).toBe('name');
+	expect(infoToPrint!.length).toBe(1);
+	expect(infoToPrint![0]).toBe(
+		`· You're about to delete ${
+			chalk.underline(
+				'name',
+			)
+		} column in companies table with 2 items`,
+	);
+	expect(shouldAskForApprove).toBe(true);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('drop autoincrement. drop column with data with pragma off', async (t) => {
+	const client = new Database(':memory:');
+
+	client.exec('PRAGMA foreign_keys=OFF;');
+
+	const users = sqliteTable('users', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+	});
+	const schema1 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			user_id: integer('user_id').references(() => users.id),
+		}),
+	};
+
+	const schema2 = {
+		companies: sqliteTable('companies', {
+			id: integer('id').primaryKey({ autoIncrement: false }),
+			user_id: integer('user_id').references(() => users.id),
+		}),
+	};
+
+	const table = getTableConfig(schema1.companies);
+	const seedStatements = [
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (1, 'drizzle');`,
+		`INSERT INTO \`${table.name}\` ("${schema1.companies.id.name}", "${schema1.companies.name.name}") VALUES (2, 'turso');`,
+	];
+
+	const {
+		sqlStatements,
+		statements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+		false,
+		seedStatements,
+	);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'recreate_table',
+		tableName: 'companies',
+		columns: [
+			{
+				name: 'id',
+				type: 'integer',
+				autoincrement: false,
+				notNull: true,
+				primaryKey: true,
+				generated: undefined,
+			},
+			{
+				name: 'user_id',
+				type: 'integer',
+				autoincrement: false,
+				notNull: false,
+				primaryKey: false,
+				generated: undefined,
+			},
+		],
+		compositePKs: [],
+		referenceData: [
+			{
+				columnsFrom: [
+					'user_id',
+				],
+				columnsTo: [
+					'id',
+				],
+				name: '',
+				onDelete: 'no action',
+				onUpdate: 'no action',
+				tableFrom: 'companies',
+				tableTo: 'users',
+			},
+		],
+		uniqueConstraints: [],
+		checkConstraints: [],
+	});
+
+	expect(sqlStatements.length).toBe(4);
+	expect(sqlStatements[0]).toBe(
+		`CREATE TABLE \`__new_companies\` (
+\t\`id\` integer PRIMARY KEY NOT NULL,
+\t\`user_id\` integer,
+\tFOREIGN KEY (\`user_id\`) REFERENCES \`users\`(\`id\`) ON UPDATE no action ON DELETE no action
+);\n`,
+	);
+	expect(sqlStatements[1]).toBe(
+		`INSERT INTO \`__new_companies\`("id", "user_id") SELECT "id", "user_id" FROM \`companies\`;`,
+	);
+	expect(sqlStatements[2]).toBe(`DROP TABLE \`companies\`;`);
+	expect(sqlStatements[3]).toBe(
+		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(1);
+	expect(infoToPrint!.length).toBe(1);
+	expect(infoToPrint![0]).toBe(
+		`· You're about to delete ${
+			chalk.underline(
+				'name',
+			)
+		} column in companies table with 2 items`,
+	);
+	expect(shouldAskForApprove).toBe(true);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('change autoincrement. other table references current', async (t) => {
+	const client = new Database(':memory:');
+
+	const companies1 = sqliteTable('companies', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+	});
+	const users1 = sqliteTable('users', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').unique(),
+		companyId: text('company_id').references(() => companies1.id),
+	});
+	const schema1 = {
+		companies: companies1,
+		users: users1,
+	};
+
+	const companies2 = sqliteTable('companies', {
+		id: integer('id').primaryKey({ autoIncrement: false }),
+	});
+	const users2 = sqliteTable('users', {
+		id: integer('id').primaryKey({ autoIncrement: true }),
+		name: text('name').unique(),
+		companyId: text('company_id').references(() => companies1.id),
+	});
+	const schema2 = {
+		companies: companies2,
+		users: users2,
+	};
+
+	const { name: usersTableName } = getTableConfig(users1);
+	const { name: companiesTableName } = getTableConfig(companies1);
+	const seedStatements = [
+		`INSERT INTO \`${usersTableName}\` ("${schema1.users.name.name}") VALUES ('drizzle');`,
+		`INSERT INTO \`${usersTableName}\` ("${schema1.users.name.name}") VALUES ('turso');`,
+		`INSERT INTO \`${companiesTableName}\` ("${schema1.companies.id.name}") VALUES ('1');`,
+		`INSERT INTO \`${companiesTableName}\` ("${schema1.companies.id.name}") VALUES ('2');`,
+	];
+
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+		false,
+		seedStatements,
+	);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'recreate_table',
+		tableName: 'companies',
+		columns: [
+			{
+				name: 'id',
+				type: 'integer',
+				autoincrement: false,
+				notNull: true,
+				primaryKey: true,
+				generated: undefined,
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		uniqueConstraints: [],
+		checkConstraints: [],
+	});
+
+	expect(sqlStatements.length).toBe(6);
+	expect(sqlStatements[0]).toBe(`PRAGMA foreign_keys=OFF;`);
+	expect(sqlStatements[1]).toBe(
+		`CREATE TABLE \`__new_companies\` (
+\t\`id\` integer PRIMARY KEY NOT NULL
+);\n`,
+	);
+	expect(sqlStatements[2]).toBe(
+		`INSERT INTO \`__new_companies\`("id") SELECT "id" FROM \`companies\`;`,
+	);
+	expect(sqlStatements[3]).toBe(`DROP TABLE \`companies\`;`);
+	expect(sqlStatements[4]).toBe(
+		`ALTER TABLE \`__new_companies\` RENAME TO \`companies\`;`,
+	);
+	expect(sqlStatements[5]).toBe(`PRAGMA foreign_keys=ON;`);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('create table with custom name references', async (t) => {
+	const client = new Database(':memory:');
+
+	const users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		name: text('name').notNull(),
+	});
+
+	const schema1 = {
+		users,
+		posts: sqliteTable(
+			'posts',
+			{
+				id: int('id').primaryKey({ autoIncrement: true }),
+				name: text('name'),
+				userId: int('user_id'),
+			},
+			(t) => ({
+				fk: foreignKey({
+					columns: [t.id],
+					foreignColumns: [users.id],
+					name: 'custom_name_fk',
+				}),
+			}),
+		),
+	};
+
+	const schema2 = {
+		users,
+		posts: sqliteTable(
+			'posts',
+			{
+				id: int('id').primaryKey({ autoIncrement: true }),
+				name: text('name'),
+				userId: int('user_id'),
+			},
+			(t) => ({
+				fk: foreignKey({
+					columns: [t.id],
+					foreignColumns: [users.id],
+					name: 'custom_name_fk',
+				}),
+			}),
+		),
+	};
+
+	const { sqlStatements } = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+	);
+
+	expect(sqlStatements!.length).toBe(0);
+});
+
+test('drop not null, add not null', async (t) => {
+	const client = new Database(':memory:');
+
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name').notNull(),
+		}),
+		posts: sqliteTable('posts', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			userId: int('user_id'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+		posts: sqliteTable('posts', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name').notNull(),
+			userId: int('user_id'),
+		}),
+	};
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(client, schema1, schema2, []);
+
+	expect(statements!.length).toBe(2);
+	expect(statements![0]).toStrictEqual({
+		checkConstraints: [],
+		columns: [
+			{
+				autoincrement: true,
+				generated: undefined,
+				name: 'id',
+				notNull: true,
+				primaryKey: true,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				generated: undefined,
+				name: 'name',
+				notNull: false,
+				primaryKey: false,
+				type: 'text',
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		tableName: 'users',
+		type: 'recreate_table',
+		uniqueConstraints: [],
+	});
+	expect(statements![1]).toStrictEqual({
+		checkConstraints: [],
+		columns: [
+			{
+				autoincrement: true,
+				generated: undefined,
+				name: 'id',
+				notNull: true,
+				primaryKey: true,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				generated: undefined,
+				name: 'name',
+				notNull: true,
+				primaryKey: false,
+				type: 'text',
+			},
+			{
+				autoincrement: false,
+				generated: undefined,
+				name: 'user_id',
+				notNull: false,
+				primaryKey: false,
+				type: 'integer',
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		tableName: 'posts',
+		type: 'recreate_table',
+		uniqueConstraints: [],
+	});
+
+	expect(sqlStatements.length).toBe(8);
+	expect(sqlStatements[0]).toBe(`CREATE TABLE \`__new_users\` (
+\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+\t\`name\` text
+);\n`);
+	expect(sqlStatements[1]).toBe(
+		`INSERT INTO \`__new_users\`("id", "name") SELECT "id", "name" FROM \`users\`;`,
+	);
+	expect(sqlStatements[2]).toBe(`DROP TABLE \`users\`;`);
+	expect(sqlStatements[3]).toBe(
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+	);
+
+	expect(sqlStatements![4]).toBe(`CREATE TABLE \`__new_posts\` (
+\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+\t\`name\` text NOT NULL,
+\t\`user_id\` integer
+);\n`);
+	expect(sqlStatements![5]).toBe(
+		`INSERT INTO \`__new_posts\`("id", "name", "user_id") SELECT "id", "name", "user_id" FROM \`posts\`;`,
+	);
+	expect(sqlStatements![6]).toBe(`DROP TABLE \`posts\`;`);
+	expect(sqlStatements![7]).toBe(
+		`ALTER TABLE \`__new_posts\` RENAME TO \`posts\`;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('rename table and change data type', async (t) => {
+	const client = new Database(':memory:');
+
+	const schema1 = {
+		users: sqliteTable('old_users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			age: text('age'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('new_users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			age: integer('age'),
+		}),
+	};
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(client, schema1, schema2, [
+		'public.old_users->public.new_users',
+	]);
+
+	expect(statements!.length).toBe(2);
+	expect(statements![0]).toStrictEqual({
+		fromSchema: undefined,
+		tableNameFrom: 'old_users',
+		tableNameTo: 'new_users',
+		toSchema: undefined,
+		type: 'rename_table',
+	});
+	expect(statements![1]).toStrictEqual({
+		columns: [
+			{
+				autoincrement: true,
+				name: 'id',
+				notNull: true,
+				generated: undefined,
+				primaryKey: true,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				name: 'age',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'integer',
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		tableName: 'new_users',
+		type: 'recreate_table',
+		uniqueConstraints: [],
+		checkConstraints: [],
+	});
+
+	expect(sqlStatements!.length).toBe(5);
+	expect(sqlStatements![0]).toBe(
+		`ALTER TABLE \`old_users\` RENAME TO \`new_users\`;`,
+	);
+	expect(sqlStatements[1]).toBe(`CREATE TABLE \`__new_new_users\` (
+\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+\t\`age\` integer
+);\n`);
+	expect(sqlStatements![2]).toBe(
+		`INSERT INTO \`__new_new_users\`("id", "age") SELECT "id", "age" FROM \`new_users\`;`,
+	);
+	expect(sqlStatements![3]).toBe(`DROP TABLE \`new_users\`;`);
+	expect(sqlStatements![4]).toBe(
+		`ALTER TABLE \`__new_new_users\` RENAME TO \`new_users\`;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('rename column and change data type', async (t) => {
+	const client = new Database(':memory:');
+
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			age: integer('age'),
+		}),
+	};
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(client, schema1, schema2, [
+		'public.users.name->public.users.age',
+	]);
+
+	expect(statements!.length).toBe(1);
+	expect(statements![0]).toStrictEqual({
+		columns: [
+			{
+				autoincrement: true,
+				name: 'id',
+				notNull: true,
+				generated: undefined,
+				primaryKey: true,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				name: 'age',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'integer',
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		tableName: 'users',
+		type: 'recreate_table',
+		uniqueConstraints: [],
+		checkConstraints: [],
+	});
+
+	expect(sqlStatements!.length).toBe(4);
+	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
+\t\`id\` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+\t\`age\` integer
+);\n`);
+	expect(sqlStatements![1]).toBe(
+		`INSERT INTO \`__new_users\`("id", "age") SELECT "id", "age" FROM \`users\`;`,
+	);
+	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
+	expect(sqlStatements![3]).toBe(
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('recreate table with nested references', async (t) => {
+	const client = new Database(':memory:');
+
+	let users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		name: text('name'),
+		age: integer('age'),
+	});
+	let subscriptions = sqliteTable('subscriptions', {
+		id: int('id').primaryKey({ autoIncrement: true }),
+		userId: integer('user_id').references(() => users.id),
+		customerId: text('customer_id'),
+	});
+	const schema1 = {
+		users: users,
+		subscriptions: subscriptions,
+		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			subscriptionId: text('subscription_id').references(
+				() => subscriptions.id,
+			),
+		}),
+	};
+
+	users = sqliteTable('users', {
+		id: int('id').primaryKey({ autoIncrement: false }),
+		name: text('name'),
+		age: integer('age'),
+	});
+	const schema2 = {
+		users: users,
+		subscriptions: subscriptions,
+		subscriptionMetadata: sqliteTable('subscriptions_metadata', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			subscriptionId: text('subscription_id').references(
+				() => subscriptions.id,
+			),
+		}),
+	};
+
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(client, schema1, schema2, [
+		'public.users.name->public.users.age',
+	]);
+
+	expect(statements!.length).toBe(1);
+	expect(statements![0]).toStrictEqual({
+		columns: [
+			{
+				autoincrement: false,
+				name: 'id',
+				notNull: true,
+				generated: undefined,
+				primaryKey: true,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				name: 'name',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'text',
+			},
+			{
+				autoincrement: false,
+				name: 'age',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'integer',
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		tableName: 'users',
+		type: 'recreate_table',
+		uniqueConstraints: [],
+		checkConstraints: [],
+	});
+
+	expect(sqlStatements!.length).toBe(6);
+	expect(sqlStatements[0]).toBe('PRAGMA foreign_keys=OFF;');
+	expect(sqlStatements![1]).toBe(`CREATE TABLE \`__new_users\` (
+\t\`id\` integer PRIMARY KEY NOT NULL,
+\t\`name\` text,
+\t\`age\` integer
+);\n`);
+	expect(sqlStatements![2]).toBe(
+		`INSERT INTO \`__new_users\`("id", "name", "age") SELECT "id", "name", "age" FROM \`users\`;`,
+	);
+	expect(sqlStatements![3]).toBe(`DROP TABLE \`users\`;`);
+	expect(sqlStatements![4]).toBe(
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+	);
+	expect(sqlStatements[5]).toBe('PRAGMA foreign_keys=ON;');
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('recreate table with added column not null and without default with data', async (t) => {
+	const client = new Database(':memory:');
+
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: true }),
+			name: text('name'),
+			age: integer('age'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+			newColumn: text('new_column').notNull(),
+		}),
+	};
+
+	const seedStatements = [
+		`INSERT INTO \`users\` ("name", "age") VALUES ('drizzle', 12)`,
+		`INSERT INTO \`users\` ("name", "age") VALUES ('turso', 12)`,
+	];
+
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+		false,
+		seedStatements,
+	);
+
+	expect(statements!.length).toBe(1);
+	expect(statements![0]).toStrictEqual({
+		columns: [
+			{
+				autoincrement: false,
+				name: 'id',
+				notNull: true,
+				generated: undefined,
+				primaryKey: true,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				name: 'name',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'text',
+			},
+			{
+				autoincrement: false,
+				name: 'age',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				name: 'new_column',
+				notNull: true,
+				generated: undefined,
+				primaryKey: false,
+				type: 'text',
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		tableName: 'users',
+		type: 'recreate_table',
+		uniqueConstraints: [],
+		checkConstraints: [],
+	});
+
+	expect(sqlStatements!.length).toBe(4);
+	expect(sqlStatements[0]).toBe('DELETE FROM \`users\`;');
+	expect(sqlStatements![1]).toBe(`CREATE TABLE \`__new_users\` (
+\t\`id\` integer PRIMARY KEY NOT NULL,
+\t\`name\` text,
+\t\`age\` integer,
+\t\`new_column\` text NOT NULL
+);\n`);
+	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
+	expect(sqlStatements![3]).toBe(
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(1);
+	expect(infoToPrint![0]).toBe(
+		`· You're about to add not-null ${
+			chalk.underline('new_column')
+		} column without default value to table, which contains 2 items`,
+	);
+	expect(shouldAskForApprove).toBe(true);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(1);
+	expect(tablesToTruncate![0]).toBe('users');
+});
+
+test('add check constraint to table', async (t) => {
+	const client = new Database(':memory:');
+
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+		}),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+		}, (table) => ({
+			someCheck: check('some_check', sql`${table.age} > 21`),
+		})),
+	};
+
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+	);
+
+	expect(statements!.length).toBe(1);
+	expect(statements![0]).toStrictEqual({
+		columns: [
+			{
+				autoincrement: false,
+				name: 'id',
+				notNull: true,
+				generated: undefined,
+				primaryKey: true,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				name: 'name',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'text',
+			},
+			{
+				autoincrement: false,
+				name: 'age',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'integer',
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		tableName: 'users',
+		type: 'recreate_table',
+		uniqueConstraints: [],
+		checkConstraints: ['some_check;"users"."age" > 21'],
+	});
+
+	expect(sqlStatements!.length).toBe(4);
+	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
+\t\`id\` integer PRIMARY KEY NOT NULL,
+\t\`name\` text,
+\t\`age\` integer,
+\tCONSTRAINT "some_check" CHECK("__new_users"."age" > 21)
+);\n`);
+	expect(sqlStatements[1]).toBe(
+		'INSERT INTO `__new_users`("id", "name", "age") SELECT "id", "name", "age" FROM `users`;',
+	);
+	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
+	expect(sqlStatements![3]).toBe(
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('drop check constraint', async (t) => {
+	const client = new Database(':memory:');
+
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+		}, (table) => ({
+			someCheck: check('some_check', sql`${table.age} > 21`),
+		})),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+		}),
+	};
+
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+	);
+
+	expect(statements!.length).toBe(1);
+	expect(statements![0]).toStrictEqual({
+		columns: [
+			{
+				autoincrement: false,
+				name: 'id',
+				notNull: true,
+				generated: undefined,
+				primaryKey: true,
+				type: 'integer',
+			},
+			{
+				autoincrement: false,
+				name: 'name',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'text',
+			},
+			{
+				autoincrement: false,
+				name: 'age',
+				notNull: false,
+				generated: undefined,
+				primaryKey: false,
+				type: 'integer',
+			},
+		],
+		compositePKs: [],
+		referenceData: [],
+		tableName: 'users',
+		type: 'recreate_table',
+		uniqueConstraints: [],
+		checkConstraints: [],
+	});
+
+	expect(sqlStatements!.length).toBe(4);
+	expect(sqlStatements![0]).toBe(`CREATE TABLE \`__new_users\` (
+\t\`id\` integer PRIMARY KEY NOT NULL,
+\t\`name\` text,
+\t\`age\` integer
+);\n`);
+	expect(sqlStatements[1]).toBe(
+		'INSERT INTO `__new_users`("id", "name", "age") SELECT "id", "name", "age" FROM `users`;',
+	);
+	expect(sqlStatements![2]).toBe(`DROP TABLE \`users\`;`);
+	expect(sqlStatements![3]).toBe(
+		`ALTER TABLE \`__new_users\` RENAME TO \`users\`;`,
+	);
+
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('db has checks. Push with same names', async () => {
+	const client = new Database(':memory:');
+
+	const schema1 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+		}, (table) => ({
+			someCheck: check('some_check', sql`${table.age} > 21`),
+		})),
+	};
+
+	const schema2 = {
+		users: sqliteTable('users', {
+			id: int('id').primaryKey({ autoIncrement: false }),
+			name: text('name'),
+			age: integer('age'),
+		}, (table) => ({
+			someCheck: check('some_check', sql`some new value`),
+		})),
+	};
+
+	const {
+		statements,
+		sqlStatements,
+		columnsToRemove,
+		infoToPrint,
+		schemasToRemove,
+		shouldAskForApprove,
+		tablesToRemove,
+		tablesToTruncate,
+	} = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+		false,
+		[],
+	);
+	expect(statements).toStrictEqual([]);
+	expect(sqlStatements).toStrictEqual([]);
+	expect(columnsToRemove!.length).toBe(0);
+	expect(infoToPrint!.length).toBe(0);
+	expect(shouldAskForApprove).toBe(false);
+	expect(tablesToRemove!.length).toBe(0);
+	expect(tablesToTruncate!.length).toBe(0);
+});
+
+test('create view', async () => {
+	const client = new Database(':memory:');
+
+	const table = sqliteTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+	};
+
+	const schema2 = {
+		test: table,
+		view: sqliteView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			definition: 'select "id" from "test"',
+			name: 'view',
+			type: 'sqlite_create_view',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		`CREATE VIEW \`view\` AS select "id" from "test";`,
+	]);
+});
+
+test('drop view', async () => {
+	const client = new Database(':memory:');
+
+	const table = sqliteTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: sqliteView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const schema2 = {
+		test: table,
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			name: 'view',
+			type: 'drop_view',
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'DROP VIEW \`view\`;',
+	]);
+});
+
+test('alter view ".as"', async () => {
+	const client = new Database(':memory:');
+
+	const table = sqliteTable('test', {
+		id: int('id').primaryKey(),
+	});
+
+	const schema1 = {
+		test: table,
+		view: sqliteView('view').as((qb) => qb.select().from(table).where(sql`${table.id} = 1`)),
+	};
+
+	const schema2 = {
+		test: table,
+		view: sqliteView('view').as((qb) => qb.select().from(table)),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+	);
+
+	expect(statements.length).toBe(0);
+	expect(sqlStatements.length).toBe(0);
+});
+
+test('create composite primary key', async (t) => {
+	const client = new Database(':memory:');
+
+	const schema1 = {};
+
+	const schema2 = {
+		table: sqliteTable('table', {
+			col1: integer('col1').notNull(),
+			col2: integer('col2').notNull(),
+		}, (t) => ({
+			pk: primaryKey({
+				columns: [t.col1, t.col2],
+			}),
+		})),
+	};
+
+	const {
+		statements,
+		sqlStatements,
+	} = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		[],
+	);
+
+	expect(statements).toStrictEqual([{
+		type: 'sqlite_create_table',
+		tableName: 'table',
+		compositePKs: [['col1', 'col2']],
+		uniqueConstraints: [],
+		referenceData: [],
+		checkConstraints: [],
+		columns: [
+			{ name: 'col1', type: 'integer', primaryKey: false, notNull: true, autoincrement: false },
+			{ name: 'col2', type: 'integer', primaryKey: false, notNull: true, autoincrement: false },
+		],
+	}]);
+	expect(sqlStatements).toStrictEqual([
+		'CREATE TABLE `table` (\n\t`col1` integer NOT NULL,\n\t`col2` integer NOT NULL,\n\tPRIMARY KEY(`col1`, `col2`)\n);\n',
+	]);
+});
+
+test('rename table with composite primary key', async () => {
+	const client = new Database(':memory:');
+
+	const productsCategoriesTable = (tableName: string) => {
+		return sqliteTable(tableName, {
+			productId: text('product_id').notNull(),
+			categoryId: text('category_id').notNull(),
+		}, (t) => ({
+			pk: primaryKey({
+				columns: [t.productId, t.categoryId],
+			}),
+		}));
+	};
+
+	const schema1 = {
+		table: productsCategoriesTable('products_categories'),
+	};
+	const schema2 = {
+		test: productsCategoriesTable('products_to_categories'),
+	};
+
+	const { sqlStatements } = await diffTestSchemasPushSqlite(
+		client,
+		schema1,
+		schema2,
+		['public.products_categories->public.products_to_categories'],
+		false,
+	);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE `products_categories` RENAME TO `products_to_categories`;',
+	]);
+});