@anthonyalayo/drizzle-kit 1.0.2 → 1.0.5

package/tests/schemaDiffer.ts

@@ -1,2852 +0,0 @@
-import { PGlite } from '@electric-sql/pglite';
-import { Client } from '@libsql/client/.';
-import { Database } from 'better-sqlite3';
-import { is } from 'drizzle-orm';
-import { MySqlSchema, MySqlTable, MySqlView } from 'drizzle-orm/mysql-core';
-import {
-	getMaterializedViewConfig,
-	isPgDomain,
-	isPgEnum,
-	isPgMaterializedView,
-	isPgSequence,
-	isPgView,
-	PgDomain,
-	PgEnum,
-	PgMaterializedView,
-	PgPolicy,
-	PgRole,
-	PgSchema,
-	PgSequence,
-	PgTable,
-	PgView,
-} from 'drizzle-orm/pg-core';
-import { SingleStoreSchema, SingleStoreTable } from 'drizzle-orm/singlestore-core';
-import { SQLiteTable, SQLiteView } from 'drizzle-orm/sqlite-core';
-import * as fs from 'fs';
-import { Connection } from 'mysql2/promise';
-import { libSqlLogSuggestionsAndReturn } from 'src/cli/commands/libSqlPushUtils';
-import {
-	columnsResolver,
-	domainsResolver,
-	enumsResolver,
-	indPolicyResolver,
-	mySqlViewsResolver,
-	Named,
-	policyResolver,
-	roleResolver,
-	schemasResolver,
-	sequencesResolver,
-	sqliteViewsResolver,
-	tablesResolver,
-	viewsResolver,
-} from 'src/cli/commands/migrate';
-import { pgSuggestions } from 'src/cli/commands/pgPushUtils';
-import { logSuggestionsAndReturn as singleStoreLogSuggestionsAndReturn } from 'src/cli/commands/singlestorePushUtils';
-import { logSuggestionsAndReturn } from 'src/cli/commands/sqlitePushUtils';
-import { Entities } from 'src/cli/validations/cli';
-import { CasingType } from 'src/cli/validations/common';
-import { snapshotVersion } from 'src/global';
-import { schemaToTypeScript as schemaToTypeScriptMySQL } from 'src/introspect-mysql';
-import { schemaToTypeScript } from 'src/introspect-pg';
-import { schemaToTypeScript as schemaToTypeScriptSingleStore } from 'src/introspect-singlestore';
-import { schemaToTypeScript as schemaToTypeScriptSQLite } from 'src/introspect-sqlite';
-import { prepareFromMySqlImports } from 'src/serializer/mysqlImports';
-import { mysqlSchema, squashMysqlScheme, ViewSquashed } from 'src/serializer/mysqlSchema';
-import { fromDatabase as fromMySqlDatabase, generateMySqlSnapshot } from 'src/serializer/mysqlSerializer';
-import { prepareFromPgImports } from 'src/serializer/pgImports';
-import { pgSchema, Policy, Role, squashPgScheme, View } from 'src/serializer/pgSchema';
-import { fromDatabase, generatePgSnapshot } from 'src/serializer/pgSerializer';
-import { prepareFromSingleStoreImports } from 'src/serializer/singlestoreImports';
-import { singlestoreSchema, squashSingleStoreScheme } from 'src/serializer/singlestoreSchema';
-import {
-	fromDatabase as fromSingleStoreDatabase,
-	generateSingleStoreSnapshot,
-} from 'src/serializer/singlestoreSerializer';
-import { prepareFromSqliteImports } from 'src/serializer/sqliteImports';
-import { sqliteSchema, squashSqliteScheme, View as SqliteView } from 'src/serializer/sqliteSchema';
-import { fromDatabase as fromSqliteDatabase, generateSqliteSnapshot } from 'src/serializer/sqliteSerializer';
-import {
-	applyLibSQLSnapshotsDiff,
-	applyMysqlSnapshotsDiff,
-	applyPgSnapshotsDiff,
-	applySingleStoreSnapshotsDiff,
-	applySqliteSnapshotsDiff,
-	Column,
-	ColumnsResolverInput,
-	ColumnsResolverOutput,
-	Domain,
-	Enum,
-	PolicyResolverInput,
-	PolicyResolverOutput,
-	ResolverInput,
-	ResolverOutput,
-	ResolverOutputWithMoved,
-	RolesResolverInput,
-	RolesResolverOutput,
-	Sequence,
-	Table,
-	TablePolicyResolverInput,
-	TablePolicyResolverOutput,
-} from 'src/snapshotsDiffer';
-
-export type PostgresSchema = Record<
-	string,
-	| PgTable<any>
-	| PgDomain<any>
-	| PgEnum<any>
-	| PgSchema
-	| PgSequence
-	| PgView
-	| PgMaterializedView
-	| PgRole
-	| PgPolicy
->;
-export type MysqlSchema = Record<
-	string,
-	MySqlTable<any> | MySqlSchema | MySqlView
->;
-export type SqliteSchema = Record<string, SQLiteTable<any> | SQLiteView>;
-export type SinglestoreSchema = Record<
-	string,
-	SingleStoreTable<any> | SingleStoreSchema /* | SingleStoreView */
->;
-
-export const testSchemasResolver =
-	(renames: Set<string>) => async (input: ResolverInput<Named>): Promise<ResolverOutput<Named>> => {
-		try {
-			if (
-				input.created.length === 0
-				|| input.deleted.length === 0
-				|| renames.size === 0
-			) {
-				return {
-					created: input.created,
-					renamed: [],
-					deleted: input.deleted,
-				};
-			}
-
-			let createdSchemas = [...input.created];
-			let deletedSchemas = [...input.deleted];
-
-			const result: {
-				created: Named[];
-				renamed: { from: Named; to: Named }[];
-				deleted: Named[];
-			} = { created: [], renamed: [], deleted: [] };
-
-			for (let rename of renames) {
-				const [from, to] = rename.split('->');
-
-				const idxFrom = deletedSchemas.findIndex((it) => {
-					return it.name === from;
-				});
-
-				if (idxFrom >= 0) {
-					const idxTo = createdSchemas.findIndex((it) => {
-						return it.name === to;
-					});
-
-					result.renamed.push({
-						from: deletedSchemas[idxFrom],
-						to: createdSchemas[idxTo],
-					});
-
-					delete createdSchemas[idxTo];
-					delete deletedSchemas[idxFrom];
-
-					createdSchemas = createdSchemas.filter(Boolean);
-					deletedSchemas = deletedSchemas.filter(Boolean);
-				}
-			}
-
-			result.created = createdSchemas;
-			result.deleted = deletedSchemas;
-
-			return result;
-		} catch (e) {
-			console.error(e);
-			throw e;
-		}
-	};
-
-export const testSequencesResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<Sequence>,
-): Promise<ResolverOutputWithMoved<Sequence>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdSequences = [...input.created];
-		let deletedSequences = [...input.deleted];
-
-		const result: {
-			created: Sequence[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: Sequence; to: Sequence }[];
-			deleted: Sequence[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedSequences.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdSequences.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const tableFrom = deletedSequences[idxFrom];
-				const tableTo = createdSequences[idxFrom];
-
-				if (tableFrom.schema !== tableTo.schema) {
-					result.moved.push({
-						name: tableFrom.name,
-						schemaFrom: tableFrom.schema,
-						schemaTo: tableTo.schema,
-					});
-				}
-
-				if (tableFrom.name !== tableTo.name) {
-					result.renamed.push({
-						from: deletedSequences[idxFrom],
-						to: createdSequences[idxTo],
-					});
-				}
-
-				delete createdSequences[idxTo];
-				delete deletedSequences[idxFrom];
-
-				createdSequences = createdSequences.filter(Boolean);
-				deletedSequences = deletedSequences.filter(Boolean);
-			}
-		}
-
-		result.created = createdSequences;
-		result.deleted = deletedSequences;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testEnumsResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<Enum>,
-): Promise<ResolverOutputWithMoved<Enum>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdEnums = [...input.created];
-		let deletedEnums = [...input.deleted];
-
-		const result: {
-			created: Enum[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: Enum; to: Enum }[];
-			deleted: Enum[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedEnums.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdEnums.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const tableFrom = deletedEnums[idxFrom];
-				const tableTo = createdEnums[idxFrom];
-
-				if (tableFrom.schema !== tableTo.schema) {
-					result.moved.push({
-						name: tableFrom.name,
-						schemaFrom: tableFrom.schema,
-						schemaTo: tableTo.schema,
-					});
-				}
-
-				if (tableFrom.name !== tableTo.name) {
-					result.renamed.push({
-						from: deletedEnums[idxFrom],
-						to: createdEnums[idxTo],
-					});
-				}
-
-				delete createdEnums[idxTo];
-				delete deletedEnums[idxFrom];
-
-				createdEnums = createdEnums.filter(Boolean);
-				deletedEnums = deletedEnums.filter(Boolean);
-			}
-		}
-
-		result.created = createdEnums;
-		result.deleted = deletedEnums;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testTablesResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<Table>,
-): Promise<ResolverOutputWithMoved<Table>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdTables = [...input.created];
-		let deletedTables = [...input.deleted];
-
-		const result: {
-			created: Table[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: Table; to: Table }[];
-			deleted: Table[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedTables.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdTables.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const tableFrom = deletedTables[idxFrom];
-				const tableTo = createdTables[idxFrom];
-
-				if (tableFrom.schema !== tableTo.schema) {
-					result.moved.push({
-						name: tableFrom.name,
-						schemaFrom: tableFrom.schema,
-						schemaTo: tableTo.schema,
-					});
-				}
-
-				if (tableFrom.name !== tableTo.name) {
-					result.renamed.push({
-						from: deletedTables[idxFrom],
-						to: createdTables[idxTo],
-					});
-				}
-
-				delete createdTables[idxTo];
-				delete deletedTables[idxFrom];
-
-				createdTables = createdTables.filter(Boolean);
-				deletedTables = deletedTables.filter(Boolean);
-			}
-		}
-
-		result.created = createdTables;
-		result.deleted = deletedTables;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testColumnsResolver = (renames: Set<string>) =>
-async (
-	input: ColumnsResolverInput<Column>,
-): Promise<ColumnsResolverOutput<Column>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				tableName: input.tableName,
-				schema: input.schema,
-				created: input.created,
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdColumns = [...input.created];
-		let deletedColumns = [...input.deleted];
-
-		const renamed: { from: Column; to: Column }[] = [];
-
-		const schema = input.schema || 'public';
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedColumns.findIndex((it) => {
-				return `${schema}.${input.tableName}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdColumns.findIndex((it) => {
-					return `${schema}.${input.tableName}.${it.name}` === to;
-				});
-
-				renamed.push({
-					from: deletedColumns[idxFrom],
-					to: createdColumns[idxTo],
-				});
-
-				delete createdColumns[idxTo];
-				delete deletedColumns[idxFrom];
-
-				createdColumns = createdColumns.filter(Boolean);
-				deletedColumns = deletedColumns.filter(Boolean);
-			}
-		}
-
-		return {
-			tableName: input.tableName,
-			schema: input.schema,
-			created: createdColumns,
-			deleted: deletedColumns,
-			renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testPolicyResolver = (renames: Set<string>) =>
-async (
-	input: TablePolicyResolverInput<Policy>,
-): Promise<TablePolicyResolverOutput<Policy>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				tableName: input.tableName,
-				schema: input.schema,
-				created: input.created,
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdPolicies = [...input.created];
-		let deletedPolicies = [...input.deleted];
-
-		const renamed: { from: Policy; to: Policy }[] = [];
-
-		const schema = input.schema || 'public';
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedPolicies.findIndex((it) => {
-				return `${schema}.${input.tableName}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdPolicies.findIndex((it) => {
-					return `${schema}.${input.tableName}.${it.name}` === to;
-				});
-
-				renamed.push({
-					from: deletedPolicies[idxFrom],
-					to: createdPolicies[idxTo],
-				});
-
-				delete createdPolicies[idxTo];
-				delete deletedPolicies[idxFrom];
-
-				createdPolicies = createdPolicies.filter(Boolean);
-				deletedPolicies = deletedPolicies.filter(Boolean);
-			}
-		}
-
-		return {
-			tableName: input.tableName,
-			schema: input.schema,
-			created: createdPolicies,
-			deleted: deletedPolicies,
-			renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testIndPolicyResolver = (renames: Set<string>) =>
-async (
-	input: PolicyResolverInput<Policy>,
-): Promise<PolicyResolverOutput<Policy>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdPolicies = [...input.created];
-		let deletedPolicies = [...input.deleted];
-
-		const renamed: { from: Policy; to: Policy }[] = [];
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedPolicies.findIndex((it) => {
-				return `${it.on}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdPolicies.findIndex((it) => {
-					return `${it.on}.${it.name}` === to;
-				});
-
-				renamed.push({
-					from: deletedPolicies[idxFrom],
-					to: createdPolicies[idxTo],
-				});
-
-				delete createdPolicies[idxTo];
-				delete deletedPolicies[idxFrom];
-
-				createdPolicies = createdPolicies.filter(Boolean);
-				deletedPolicies = deletedPolicies.filter(Boolean);
-			}
-		}
-
-		return {
-			created: createdPolicies,
-			deleted: deletedPolicies,
-			renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testRolesResolver = (renames: Set<string>) =>
-async (
-	input: RolesResolverInput<Role>,
-): Promise<RolesResolverOutput<Role>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdPolicies = [...input.created];
-		let deletedPolicies = [...input.deleted];
-
-		const renamed: { from: Policy; to: Policy }[] = [];
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedPolicies.findIndex((it) => {
-				return `${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdPolicies.findIndex((it) => {
-					return `${it.name}` === to;
-				});
-
-				renamed.push({
-					from: deletedPolicies[idxFrom],
-					to: createdPolicies[idxTo],
-				});
-
-				delete createdPolicies[idxTo];
-				delete deletedPolicies[idxFrom];
-
-				createdPolicies = createdPolicies.filter(Boolean);
-				deletedPolicies = deletedPolicies.filter(Boolean);
-			}
-		}
-
-		return {
-			created: createdPolicies,
-			deleted: deletedPolicies,
-			renamed,
-		};
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testDomainsResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<Domain>,
-): Promise<ResolverOutputWithMoved<Domain>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdDomains = [...input.created];
-		let deletedDomains = [...input.deleted];
-
-		const result: {
-			created: Domain[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: Domain; to: Domain }[];
-			deleted: Domain[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedDomains.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdDomains.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const domainFrom = deletedDomains[idxFrom];
-				const domainTo = createdDomains[idxFrom];
-
-				if (domainFrom.schema !== domainTo.schema) {
-					result.moved.push({
-						name: domainFrom.name,
-						schemaFrom: domainFrom.schema,
-						schemaTo: domainTo.schema,
-					});
-				}
-
-				if (domainFrom.name !== domainTo.name) {
-					result.renamed.push({
-						from: deletedDomains[idxFrom],
-						to: createdDomains[idxTo],
-					});
-				}
-
-				delete createdDomains[idxTo];
-				delete deletedDomains[idxFrom];
-
-				createdDomains = createdDomains.filter(Boolean);
-				deletedDomains = deletedDomains.filter(Boolean);
-			}
-		}
-
-		result.created = createdDomains;
-		result.deleted = deletedDomains;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testViewsResolver = (renames: Set<string>) =>
-async (
-	input: ResolverInput<View>,
-): Promise<ResolverOutputWithMoved<View>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdViews = [...input.created];
-		let deletedViews = [...input.deleted];
-
-		const result: {
-			created: View[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: View; to: View }[];
-			deleted: View[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedViews.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdViews.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const viewFrom = deletedViews[idxFrom];
-				const viewTo = createdViews[idxFrom];
-
-				if (viewFrom.schema !== viewTo.schema) {
-					result.moved.push({
-						name: viewFrom.name,
-						schemaFrom: viewFrom.schema,
-						schemaTo: viewTo.schema,
-					});
-				}
-
-				if (viewFrom.name !== viewTo.name) {
-					result.renamed.push({
-						from: deletedViews[idxFrom],
-						to: createdViews[idxTo],
-					});
-				}
-
-				delete createdViews[idxTo];
-				delete deletedViews[idxFrom];
-
-				createdViews = createdViews.filter(Boolean);
-				deletedViews = deletedViews.filter(Boolean);
-			}
-		}
-
-		result.created = createdViews;
-		result.deleted = deletedViews;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testViewsResolverMySql = (renames: Set<string>) =>
-async (
-	input: ResolverInput<ViewSquashed & { schema: '' }>,
-): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdViews = [...input.created];
-		let deletedViews = [...input.deleted];
-
-		const result: {
-			created: ViewSquashed[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: ViewSquashed; to: ViewSquashed }[];
-			deleted: ViewSquashed[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedViews.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdViews.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const viewFrom = deletedViews[idxFrom];
-				const viewTo = createdViews[idxFrom];
-
-				if (viewFrom.schema !== viewTo.schema) {
-					result.moved.push({
-						name: viewFrom.name,
-						schemaFrom: viewFrom.schema,
-						schemaTo: viewTo.schema,
-					});
-				}
-
-				if (viewFrom.name !== viewTo.name) {
-					result.renamed.push({
-						from: deletedViews[idxFrom],
-						to: createdViews[idxTo],
-					});
-				}
-
-				delete createdViews[idxTo];
-				delete deletedViews[idxFrom];
-
-				createdViews = createdViews.filter(Boolean);
-				deletedViews = deletedViews.filter(Boolean);
-			}
-		}
-
-		result.created = createdViews;
-		result.deleted = deletedViews;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testViewsResolverSingleStore = (renames: Set<string>) =>
-async (
-	input: ResolverInput<ViewSquashed & { schema: '' }>,
-): Promise<ResolverOutputWithMoved<ViewSquashed>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdViews = [...input.created];
-		let deletedViews = [...input.deleted];
-
-		const result: {
-			created: ViewSquashed[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: ViewSquashed; to: ViewSquashed }[];
-			deleted: ViewSquashed[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedViews.findIndex((it) => {
-				return `${it.schema || 'public'}.${it.name}` === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdViews.findIndex((it) => {
-					return `${it.schema || 'public'}.${it.name}` === to;
-				});
-
-				const viewFrom = deletedViews[idxFrom];
-				const viewTo = createdViews[idxFrom];
-
-				if (viewFrom.schema !== viewTo.schema) {
-					result.moved.push({
-						name: viewFrom.name,
-						schemaFrom: viewFrom.schema,
-						schemaTo: viewTo.schema,
-					});
-				}
-
-				if (viewFrom.name !== viewTo.name) {
-					result.renamed.push({
-						from: deletedViews[idxFrom],
-						to: createdViews[idxTo],
-					});
-				}
-
-				delete createdViews[idxTo];
-				delete deletedViews[idxFrom];
-
-				createdViews = createdViews.filter(Boolean);
-				deletedViews = deletedViews.filter(Boolean);
-			}
-		}
-
-		result.created = createdViews;
-		result.deleted = deletedViews;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const testViewsResolverSqlite = (renames: Set<string>) =>
-async (
-	input: ResolverInput<SqliteView>,
-): Promise<ResolverOutputWithMoved<SqliteView>> => {
-	try {
-		if (
-			input.created.length === 0
-			|| input.deleted.length === 0
-			|| renames.size === 0
-		) {
-			return {
-				created: input.created,
-				moved: [],
-				renamed: [],
-				deleted: input.deleted,
-			};
-		}
-
-		let createdViews = [...input.created];
-		let deletedViews = [...input.deleted];
-
-		const result: {
-			created: SqliteView[];
-			moved: { name: string; schemaFrom: string; schemaTo: string }[];
-			renamed: { from: SqliteView; to: SqliteView }[];
-			deleted: SqliteView[];
-		} = { created: [], renamed: [], deleted: [], moved: [] };
-
-		for (let rename of renames) {
-			const [from, to] = rename.split('->');
-
-			const idxFrom = deletedViews.findIndex((it) => {
-				return it.name === from;
-			});
-
-			if (idxFrom >= 0) {
-				const idxTo = createdViews.findIndex((it) => {
-					return it.name === to;
-				});
-
-				const viewFrom = deletedViews[idxFrom];
-				const viewTo = createdViews[idxFrom];
-
-				if (viewFrom.name !== viewTo.name) {
-					result.renamed.push({
-						from: deletedViews[idxFrom],
-						to: createdViews[idxTo],
-					});
-				}
-
-				delete createdViews[idxTo];
-				delete deletedViews[idxFrom];
-
-				createdViews = createdViews.filter(Boolean);
-				deletedViews = deletedViews.filter(Boolean);
-			}
-		}
-
-		result.created = createdViews;
-		result.deleted = deletedViews;
-
-		return result;
-	} catch (e) {
-		console.error(e);
-		throw e;
-	}
-};
-
-export const diffTestSchemasPush = async (
-	client: PGlite,
-	left: PostgresSchema,
-	right: PostgresSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	schemas: string[] = ['public'],
-	casing?: CasingType | undefined,
-	entities?: Entities,
-	sqlStatementsToRun: {
-		before?: string[];
-		after?: string[];
-		runApply?: boolean;
-	} = {
-		before: [],
-		after: [],
-		runApply: true,
-	},
-) => {
-	const shouldRunApply = sqlStatementsToRun.runApply === undefined
-		? true
-		: sqlStatementsToRun.runApply;
-
-	for (const st of sqlStatementsToRun.before ?? []) {
-		await client.query(st);
-	}
-
-	if (shouldRunApply) {
-		const res = await applyPgDiffs(left, casing);
-		for (const st of res.sqlStatements) {
-			await client.query(st);
-		}
-	}
-
-	for (const st of sqlStatementsToRun.after ?? []) {
-		await client.query(st);
-	}
-
-	const materializedViewsForRefresh = Object.values(left).filter((it) =>
-		isPgMaterializedView(it)
-	) as PgMaterializedView[];
-
-	// refresh all mat views
-	for (const view of materializedViewsForRefresh) {
-		const viewConf = getMaterializedViewConfig(view);
-		if (viewConf.isExisting) continue;
-
-		await client.exec(
-			`REFRESH MATERIALIZED VIEW "${viewConf.schema ?? 'public'}"."${viewConf.name}"${
-				viewConf.withNoData ? ' WITH NO DATA;' : ';'
-			}`,
-		);
-	}
-
-	// do introspect into PgSchemaInternal
-	const introspectedSchema = await fromDatabase(
-		{
-			query: async (query: string, values?: any[] | undefined) => {
-				const res = await client.query(query, values);
-				return res.rows as any[];
-			},
-		},
-		undefined,
-		schemas,
-		entities,
-	);
-
-	const leftTables = Object.values(right).filter((it) => is(it, PgTable)) as PgTable[];
-
-	const leftSchemas = Object.values(right).filter((it) => is(it, PgSchema)) as PgSchema[];
-
-	const leftEnums = Object.values(right).filter((it) => isPgEnum(it)) as PgEnum<any>[];
-
-	const leftSequences = Object.values(right).filter((it) => isPgSequence(it)) as PgSequence[];
-
-	const leftDomains = Object.values(right).filter((it) => isPgDomain(it)) as PgDomain<any>[];
-
-	const leftRoles = Object.values(right).filter((it) => is(it, PgRole)) as PgRole[];
-
-	const leftPolicies = Object.values(right).filter((it) => is(it, PgPolicy)) as PgPolicy[];
-
-	const leftViews = Object.values(right).filter((it) => isPgView(it)) as PgView[];
-
-	const leftMaterializedViews = Object.values(right).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
-
-	const serialized2 = generatePgSnapshot(
-		leftTables,
-		leftDomains,
-		leftEnums,
-		leftSchemas,
-		leftSequences,
-		leftRoles,
-		leftPolicies,
-		leftViews,
-		leftMaterializedViews,
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: snapshotVersion,
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: snapshotVersion,
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashPgScheme(sch1, 'push');
-	const sn2 = squashPgScheme(sch2, 'push');
-
-	const validatedPrev = pgSchema.parse(sch1);
-	const validatedCur = pgSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-			sn1,
-			sn2,
-			testSchemasResolver(renames),
-			testDomainsResolver(renames),
-			testEnumsResolver(renames),
-			testSequencesResolver(renames),
-			testPolicyResolver(renames),
-			testIndPolicyResolver(renames),
-			testRolesResolver(renames),
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolver(renames),
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-
-		const {
-			shouldAskForApprove,
-			statementsToExecute,
-			columnsToRemove,
-			tablesToRemove,
-			tablesToTruncate,
-			infoToPrint,
-			schemasToRemove,
-			matViewsToRemove,
-		} = await pgSuggestions(
-			{
-				query: async <T>(sql: string, params: any[] = []) => {
-					return (await client.query(sql, params)).rows as T[];
-				},
-			},
-			statements,
-		);
-
-		return {
-			sqlStatements: statementsToExecute,
-			statements,
-			shouldAskForApprove,
-			columnsToRemove,
-			tablesToRemove,
-			tablesToTruncate,
-			infoToPrint,
-			schemasToRemove,
-			matViewsToRemove,
-		};
-	} else {
-		const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-			sn1,
-			sn2,
-			schemasResolver,
-			domainsResolver,
-			enumsResolver,
-			sequencesResolver,
-			policyResolver,
-			indPolicyResolver,
-			roleResolver,
-			tablesResolver,
-			columnsResolver,
-			viewsResolver,
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export const applyPgDiffs = async (
-	sn: PostgresSchema,
-	casing: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: snapshotVersion,
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		tables: {},
-		domains: {},
-		enums: {},
-		views: {},
-		schemas: {},
-		sequences: {},
-		policies: {},
-		roles: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, PgTable)) as PgTable[];
-
-	const schemas = Object.values(sn).filter((it) => is(it, PgSchema)) as PgSchema[];
-
-	const domains = Object.values(sn).filter((it) => isPgDomain(it)) as PgDomain<any>[];
-
-	const enums = Object.values(sn).filter((it) => isPgEnum(it)) as PgEnum<any>[];
-
-	const sequences = Object.values(sn).filter((it) => isPgSequence(it)) as PgSequence[];
-
-	const roles = Object.values(sn).filter((it) => is(it, PgRole)) as PgRole[];
-
-	const views = Object.values(sn).filter((it) => isPgView(it)) as PgView[];
-
-	const policies = Object.values(sn).filter((it) => is(it, PgPolicy)) as PgPolicy[];
-
-	const materializedViews = Object.values(sn).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
-
-	const serialized1 = generatePgSnapshot(
-		tables,
-		domains,
-		enums,
-		schemas,
-		sequences,
-		roles,
-		policies,
-		views,
-		materializedViews,
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: snapshotVersion,
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashPgScheme(sch1);
-
-	const validatedPrev = pgSchema.parse(dryRun);
-	const validatedCur = pgSchema.parse(sch1);
-
-	const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-		dryRun,
-		sn1,
-		testSchemasResolver(new Set()),
-		testDomainsResolver(new Set()),
-		testEnumsResolver(new Set()),
-		testSequencesResolver(new Set()),
-		testPolicyResolver(new Set()),
-		testIndPolicyResolver(new Set()),
-		testRolesResolver(new Set()),
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolver(new Set()),
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemas = async (
-	left: PostgresSchema,
-	right: PostgresSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, PgTable)) as PgTable[];
-
-	const rightTables = Object.values(right).filter((it) => is(it, PgTable)) as PgTable[];
-
-	const leftSchemas = Object.values(left).filter((it) => is(it, PgSchema)) as PgSchema[];
-
-	const rightSchemas = Object.values(right).filter((it) => is(it, PgSchema)) as PgSchema[];
-
-	const leftEnums = Object.values(left).filter((it) => isPgEnum(it)) as PgEnum<any>[];
-
-	const rightEnums = Object.values(right).filter((it) => isPgEnum(it)) as PgEnum<any>[];
-
-	const leftSequences = Object.values(left).filter((it) => isPgSequence(it)) as PgSequence[];
-
-	const rightSequences = Object.values(right).filter((it) => isPgSequence(it)) as PgSequence[];
-
-	const leftDomains = Object.values(left).filter((it) => isPgDomain(it)) as PgDomain<any>[];
-
-	const rightDomains = Object.values(right).filter((it) => isPgDomain(it)) as PgDomain<any>[];
-
-	const leftRoles = Object.values(left).filter((it) => is(it, PgRole)) as PgRole[];
-
-	const rightRoles = Object.values(right).filter((it) => is(it, PgRole)) as PgRole[];
-
-	const leftPolicies = Object.values(left).filter((it) => is(it, PgPolicy)) as PgPolicy[];
-
-	const rightPolicies = Object.values(right).filter((it) => is(it, PgPolicy)) as PgPolicy[];
-
-	const leftViews = Object.values(left).filter((it) => isPgView(it)) as PgView[];
-
-	const rightViews = Object.values(right).filter((it) => isPgView(it)) as PgView[];
-
-	const leftMaterializedViews = Object.values(left).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
-
-	const rightMaterializedViews = Object.values(right).filter((it) => isPgMaterializedView(it)) as PgMaterializedView[];
-
-	const serialized1 = generatePgSnapshot(
-		leftTables,
-		leftDomains,
-		leftEnums,
-		leftSchemas,
-		leftSequences,
-		leftRoles,
-		leftPolicies,
-		leftViews,
-		leftMaterializedViews,
-		casing,
-	);
-	const serialized2 = generatePgSnapshot(
-		rightTables,
-		rightDomains,
-		rightEnums,
-		rightSchemas,
-		rightSequences,
-		rightRoles,
-		rightPolicies,
-		rightViews,
-		rightMaterializedViews,
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: snapshotVersion,
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: snapshotVersion,
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashPgScheme(sch1);
-	const sn2 = squashPgScheme(sch2);
-
-	const validatedPrev = pgSchema.parse(sch1);
-	const validatedCur = pgSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-			sn1,
-			sn2,
-			testSchemasResolver(renames),
-			testDomainsResolver(renames),
-			testEnumsResolver(renames),
-			testSequencesResolver(renames),
-			testPolicyResolver(renames),
-			testIndPolicyResolver(renames),
-			testRolesResolver(renames),
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolver(renames),
-			validatedPrev,
-			validatedCur,
-		);
-		return { sqlStatements, statements };
-	} else {
-		const { sqlStatements, statements } = await applyPgSnapshotsDiff(
-			sn1,
-			sn2,
-			schemasResolver,
-			domainsResolver,
-			enumsResolver,
-			sequencesResolver,
-			policyResolver,
-			indPolicyResolver,
-			roleResolver,
-			tablesResolver,
-			columnsResolver,
-			viewsResolver,
-			validatedPrev,
-			validatedCur,
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export const diffTestSchemasPushMysql = async (
-	client: Connection,
-	left: MysqlSchema,
-	right: MysqlSchema,
-	renamesArr: string[],
-	schema: string,
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const { sqlStatements } = await applyMySqlDiffs(left, casing);
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-	// do introspect into PgSchemaInternal
-	const introspectedSchema = await fromMySqlDatabase(
-		{
-			query: async (sql: string, params?: any[]) => {
-				const res = await client.execute(sql, params);
-				return res[0] as any;
-			},
-		},
-		schema,
-	);
-
-	const leftTables = Object.values(right).filter((it) => is(it, MySqlTable)) as MySqlTable[];
-
-	const leftViews = Object.values(right).filter((it) => is(it, MySqlView)) as MySqlView[];
-
-	const serialized2 = generateMySqlSnapshot(leftTables, leftViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashMysqlScheme(sch1);
-	const sn2 = squashMysqlScheme(sch2);
-
-	const validatedPrev = mysqlSchema.parse(sch1);
-	const validatedCur = mysqlSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverMySql(renames),
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-		return { sqlStatements, statements };
-	} else {
-		const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-			sn1,
-			sn2,
-			tablesResolver,
-			columnsResolver,
-			mySqlViewsResolver,
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export const applyMySqlDiffs = async (
-	sn: MysqlSchema,
-	casing: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		views: {},
-		tables: {},
-		enums: {},
-		schemas: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, MySqlTable)) as MySqlTable[];
-
-	const views = Object.values(sn).filter((it) => is(it, MySqlView)) as MySqlView[];
-
-	const serialized1 = generateMySqlSnapshot(tables, views, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashMysqlScheme(sch1);
-
-	const validatedPrev = mysqlSchema.parse(dryRun);
-	const validatedCur = mysqlSchema.parse(sch1);
-
-	const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-		dryRun,
-		sn1,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverMySql(new Set()),
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasMysql = async (
-	left: MysqlSchema,
-	right: MysqlSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, MySqlTable)) as MySqlTable[];
-
-	const leftViews = Object.values(left).filter((it) => is(it, MySqlView)) as MySqlView[];
-
-	const rightTables = Object.values(right).filter((it) => is(it, MySqlTable)) as MySqlTable[];
-
-	const rightViews = Object.values(right).filter((it) => is(it, MySqlView)) as MySqlView[];
-
-	const serialized1 = generateMySqlSnapshot(leftTables, leftViews, casing);
-	const serialized2 = generateMySqlSnapshot(rightTables, rightViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashMysqlScheme(sch1);
-	const sn2 = squashMysqlScheme(sch2);
-
-	const validatedPrev = mysqlSchema.parse(sch1);
-	const validatedCur = mysqlSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverMySql(renames),
-			validatedPrev,
-			validatedCur,
-		);
-		return { sqlStatements, statements };
-	}
-
-	const { sqlStatements, statements } = await applyMysqlSnapshotsDiff(
-		sn1,
-		sn2,
-		tablesResolver,
-		columnsResolver,
-		mySqlViewsResolver,
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasSingleStore = async (
-	left: SinglestoreSchema,
-	right: SinglestoreSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	/* const leftViews = Object.values(left).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
-
-	const rightTables = Object.values(right).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	/* const rightViews = Object.values(right).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
-
-	const serialized1 = generateSingleStoreSnapshot(
-		leftTables,
-		/* leftViews, */
-		casing,
-	);
-	const serialized2 = generateSingleStoreSnapshot(
-		rightTables,
-		/* rightViews, */
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSingleStoreScheme(sch1);
-	const sn2 = squashSingleStoreScheme(sch2);
-
-	const validatedPrev = singlestoreSchema.parse(sch1);
-	const validatedCur = singlestoreSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			/* testViewsResolverSingleStore(renames), */
-			validatedPrev,
-			validatedCur,
-		);
-		return { sqlStatements, statements };
-	}
-
-	const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-		sn1,
-		sn2,
-		tablesResolver,
-		columnsResolver,
-		/* singleStoreViewsResolver, */
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasPushSingleStore = async (
-	client: Connection,
-	left: SinglestoreSchema,
-	right: SinglestoreSchema,
-	renamesArr: string[],
-	schema: string,
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-	sqlStatementsToRun: {
-		before?: string[];
-		after?: string[];
-		runApply?: boolean;
-	} = {
-		before: [],
-		after: [],
-		runApply: true,
-	},
-) => {
-	const shouldRunApply = sqlStatementsToRun.runApply === undefined
-		? true
-		: sqlStatementsToRun.runApply;
-
-	for (const st of sqlStatementsToRun.before ?? []) {
-		await client.query(st);
-	}
-
-	if (shouldRunApply) {
-		const res = await applySingleStoreDiffs(left, casing);
-		for (const st of res.sqlStatements) {
-			await client.query(st);
-		}
-	}
-
-	for (const st of sqlStatementsToRun.after ?? []) {
-		await client.query(st);
-	}
-
-	// do introspect into PgSchemaInternal
-	const introspectedSchema = await fromSingleStoreDatabase(
-		{
-			query: async (sql: string, params?: any[]) => {
-				const res = await client.execute(sql, params);
-				return res[0] as any;
-			},
-		},
-		schema,
-	);
-
-	const leftTables = Object.values(right).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	/* const leftViews = Object.values(right).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
-
-	const serialized2 = generateSingleStoreSnapshot(
-		leftTables,
-		/* leftViews, */
-		casing,
-	);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSingleStoreScheme(sch1);
-	const sn2 = squashSingleStoreScheme(sch2);
-
-	const validatedPrev = singlestoreSchema.parse(sch1);
-	const validatedCur = singlestoreSchema.parse(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			/* testViewsResolverSingleStore(renames), */
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-
-		const {
-			statementsToExecute,
-			columnsToRemove,
-			infoToPrint,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		} = await singleStoreLogSuggestionsAndReturn(
-			{
-				query: async <T>(sql: string, params?: any[]) => {
-					const res = await client.execute(sql, params);
-					return res[0] as T[];
-				},
-			},
-			statements,
-			sn1,
-			sn2,
-		);
-
-		return {
-			sqlStatements: statementsToExecute,
-			statements,
-			columnsToRemove,
-			infoToPrint,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		};
-	} else {
-		const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-			sn1,
-			sn2,
-			tablesResolver,
-			columnsResolver,
-			/* singleStoreViewsResolver, */
-			validatedPrev,
-			validatedCur,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export const applySingleStoreDiffs = async (
-	sn: SinglestoreSchema,
-	casing: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		tables: {},
-		views: {},
-		enums: {},
-		schemas: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	/* const views = Object.values(sn).filter((it) => is(it, SingleStoreView)) as SingleStoreView[]; */
-
-	const serialized1 = generateSingleStoreSnapshot(tables, /* views, */ casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashSingleStoreScheme(sch1);
-
-	const validatedPrev = singlestoreSchema.parse(dryRun);
-	const validatedCur = singlestoreSchema.parse(sch1);
-
-	const { sqlStatements, statements } = await applySingleStoreSnapshotsDiff(
-		dryRun,
-		sn1,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		/* testViewsResolverSingleStore(new Set()), */
-		validatedPrev,
-		validatedCur,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasPushSqlite = async (
-	client: Database,
-	left: SqliteSchema,
-	right: SqliteSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	seedStatements: string[] = [],
-	casing?: CasingType | undefined,
-) => {
-	const { sqlStatements } = await applySqliteDiffs(left, 'push');
-
-	for (const st of sqlStatements) {
-		client.exec(st);
-	}
-
-	for (const st of seedStatements) {
-		client.exec(st);
-	}
-
-	// do introspect into PgSchemaInternal
-	const introspectedSchema = await fromSqliteDatabase(
-		{
-			query: async <T>(sql: string, params: any[] = []) => {
-				return client.prepare(sql).bind(params).all() as T[];
-			},
-			run: async (query: string) => {
-				client.prepare(query).run();
-			},
-		},
-		undefined,
-	);
-
-	const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1, 'push');
-	const sn2 = squashSqliteScheme(sch2, 'push');
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements, _meta } = await applySqliteSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverSqlite(renames),
-			sch1,
-			sch2,
-			'push',
-		);
-
-		const {
-			statementsToExecute,
-			columnsToRemove,
-			infoToPrint,
-			schemasToRemove,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		} = await logSuggestionsAndReturn(
-			{
-				query: async <T>(sql: string, params: any[] = []) => {
-					return client.prepare(sql).bind(params).all() as T[];
-				},
-				run: async (query: string) => {
-					client.prepare(query).run();
-				},
-			},
-			statements,
-			sn1,
-			sn2,
-			_meta!,
-		);
-
-		return {
-			sqlStatements: statementsToExecute,
-			statements,
-			columnsToRemove,
-			infoToPrint,
-			schemasToRemove,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		};
-	} else {
-		const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
-			sn1,
-			sn2,
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			sch1,
-			sch2,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-};
-
-export async function diffTestSchemasPushLibSQL(
-	client: Client,
-	left: SqliteSchema,
-	right: SqliteSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	seedStatements: string[] = [],
-	casing?: CasingType | undefined,
-) {
-	const { sqlStatements } = await applyLibSQLDiffs(left, 'push');
-
-	for (const st of sqlStatements) {
-		await client.execute(st);
-	}
-
-	for (const st of seedStatements) {
-		await client.execute(st);
-	}
-
-	const introspectedSchema = await fromSqliteDatabase(
-		{
-			query: async <T>(sql: string, params?: any[]) => {
-				const res = await client.execute({ sql, args: params || [] });
-				return res.rows as T[];
-			},
-			run: async (query: string) => {
-				await client.execute(query);
-			},
-		},
-		undefined,
-	);
-
-	const leftTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const leftViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized2 = generateSqliteSnapshot(leftTables, leftViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = introspectedSchema;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1, 'push');
-	const sn2 = squashSqliteScheme(sch2, 'push');
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements, _meta } = await applyLibSQLSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverSqlite(renames),
-			sch1,
-			sch2,
-			'push',
-		);
-
-		const {
-			statementsToExecute,
-			columnsToRemove,
-			infoToPrint,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		} = await libSqlLogSuggestionsAndReturn(
-			{
-				query: async <T>(sql: string, params?: any[]) => {
-					const res = await client.execute({ sql, args: params || [] });
-					return res.rows as T[];
-				},
-				run: async (query: string) => {
-					await client.execute(query);
-				},
-			},
-			statements,
-			sn1,
-			sn2,
-			_meta!,
-		);
-
-		return {
-			sqlStatements: statementsToExecute,
-			statements,
-			columnsToRemove,
-			infoToPrint,
-			shouldAskForApprove,
-			tablesToRemove,
-			tablesToTruncate,
-		};
-	} else {
-		const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
-			sn1,
-			sn2,
-			tablesResolver,
-			columnsResolver,
-			sqliteViewsResolver,
-			sch1,
-			sch2,
-			'push',
-		);
-		return { sqlStatements, statements };
-	}
-}
-
-export const applySqliteDiffs = async (
-	sn: SqliteSchema,
-	action?: 'push' | undefined,
-	casing?: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		tables: {},
-		enums: {},
-		views: {},
-		schemas: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const views = Object.values(sn).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized1 = generateSqliteSnapshot(tables, views, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1, action);
-
-	const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
-		dryRun,
-		sn1,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverSqlite(new Set()),
-		dryRun,
-		sch1,
-		action,
-	);
-
-	return { sqlStatements, statements };
-};
-
-export const applyLibSQLDiffs = async (
-	sn: SqliteSchema,
-	action?: 'push' | undefined,
-	casing?: CasingType | undefined,
-) => {
-	const dryRun = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		tables: {},
-		views: {},
-		enums: {},
-		schemas: {},
-		_meta: {
-			schemas: {},
-			tables: {},
-			columns: {},
-		},
-	} as const;
-
-	const tables = Object.values(sn).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const views = Object.values(sn).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized1 = generateSqliteSnapshot(tables, views, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1, action);
-
-	const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
-		dryRun,
-		sn1,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverSqlite(new Set()),
-		dryRun,
-		sch1,
-		action,
-	);
-
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasSqlite = async (
-	left: SqliteSchema,
-	right: SqliteSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const leftViews = Object.values(left).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized1 = generateSqliteSnapshot(leftTables, leftViews, casing);
-	const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1);
-	const sn2 = squashSqliteScheme(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverSqlite(renames),
-			sch1,
-			sch2,
-		);
-		return { sqlStatements, statements };
-	}
-
-	const { sqlStatements, statements } = await applySqliteSnapshotsDiff(
-		sn1,
-		sn2,
-		tablesResolver,
-		columnsResolver,
-		sqliteViewsResolver,
-		sch1,
-		sch2,
-	);
-	return { sqlStatements, statements };
-};
-
-export const diffTestSchemasLibSQL = async (
-	left: SqliteSchema,
-	right: SqliteSchema,
-	renamesArr: string[],
-	cli: boolean = false,
-	casing?: CasingType | undefined,
-) => {
-	const leftTables = Object.values(left).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const leftViews = Object.values(left).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const rightTables = Object.values(right).filter((it) => is(it, SQLiteTable)) as SQLiteTable[];
-
-	const rightViews = Object.values(right).filter((it) => is(it, SQLiteView)) as SQLiteView[];
-
-	const serialized1 = generateSqliteSnapshot(leftTables, leftViews, casing);
-	const serialized2 = generateSqliteSnapshot(rightTables, rightViews, casing);
-
-	const { version: v1, dialect: d1, ...rest1 } = serialized1;
-	const { version: v2, dialect: d2, ...rest2 } = serialized2;
-
-	const sch1 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest1,
-	} as const;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn1 = squashSqliteScheme(sch1);
-	const sn2 = squashSqliteScheme(sch2);
-
-	const renames = new Set(renamesArr);
-
-	if (!cli) {
-		const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
-			sn1,
-			sn2,
-			testTablesResolver(renames),
-			testColumnsResolver(renames),
-			testViewsResolverSqlite(renames),
-			sch1,
-			sch2,
-		);
-		return { sqlStatements, statements };
-	}
-
-	const { sqlStatements, statements } = await applyLibSQLSnapshotsDiff(
-		sn1,
-		sn2,
-		tablesResolver,
-		columnsResolver,
-		sqliteViewsResolver,
-		sch1,
-		sch2,
-	);
-	return { sqlStatements, statements };
-};
-
-// --- Introspect to file helpers ---
-
-export const introspectPgToFile = async (
-	client: PGlite,
-	initSchema: PostgresSchema,
-	testName: string,
-	schemas: string[] = ['public'],
-	entities?: Entities,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applyPgDiffs(initSchema, casing);
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromDatabase(
-		{
-			query: async (query: string, values?: any[] | undefined) => {
-				const res = await client.query(query, values);
-				return res.rows as any[];
-			},
-		},
-		undefined,
-		schemas,
-		entities,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
-
-	const initSch = {
-		version: snapshotVersion,
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashPgScheme(initSch);
-	const validatedCur = pgSchema.parse(initSch);
-
-	// write to ts file
-	const file = schemaToTypeScript(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/postgres/${testName}.ts`, file.file);
-
-	// generate snapshot from ts file
-	const response = await prepareFromPgImports([
-		`tests/introspect/postgres/${testName}.ts`,
-	]);
-
-	const afterFileImports = generatePgSnapshot(
-		response.tables,
-		response.domains,
-		response.enums,
-		response.schemas,
-		response.sequences,
-		response.roles,
-		response.policies,
-		response.views,
-		response.matViews,
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: snapshotVersion,
-		dialect: 'postgresql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashPgScheme(sch2);
-	const validatedCurAfterImport = pgSchema.parse(sch2);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applyPgSnapshotsDiff(
-		initSn,
-		sn2AfterIm,
-		testSchemasResolver(new Set()),
-		testDomainsResolver(new Set()),
-		testEnumsResolver(new Set()),
-		testSequencesResolver(new Set()),
-		testPolicyResolver(new Set()),
-		testIndPolicyResolver(new Set()),
-		testRolesResolver(new Set()),
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolver(new Set()),
-		validatedCur,
-		validatedCurAfterImport,
-	);
-
-	fs.rmSync(`tests/introspect/postgres/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
-
-export const introspectMySQLToFile = async (
-	client: Connection,
-	initSchema: MysqlSchema,
-	testName: string,
-	schema: string,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applyMySqlDiffs(initSchema, casing);
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromMySqlDatabase(
-		{
-			query: async (sql: string, params?: any[] | undefined) => {
-				const res = await client.execute(sql, params);
-				return res[0] as any;
-			},
-		},
-		schema,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
-
-	const initSch = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashMysqlScheme(initSch);
-	const validatedCur = mysqlSchema.parse(initSch);
-
-	const file = schemaToTypeScriptMySQL(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/mysql/${testName}.ts`, file.file);
-
-	const response = await prepareFromMySqlImports([
-		`tests/introspect/mysql/${testName}.ts`,
-	]);
-
-	const afterFileImports = generateMySqlSnapshot(
-		response.tables,
-		response.views,
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '5',
-		dialect: 'mysql',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashMysqlScheme(sch2);
-	const validatedCurAfterImport = mysqlSchema.parse(sch2);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applyMysqlSnapshotsDiff(
-		sn2AfterIm,
-		initSn,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverMySql(new Set()),
-		validatedCurAfterImport,
-		validatedCur,
-	);
-
-	fs.rmSync(`tests/introspect/mysql/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
-
-export const introspectSingleStoreToFile = async (
-	client: Connection,
-	initSchema: SinglestoreSchema,
-	testName: string,
-	schema: string,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applySingleStoreDiffs(initSchema, casing);
-	for (const st of sqlStatements) {
-		await client.query(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromSingleStoreDatabase(
-		{
-			query: async (sql: string, params?: any[] | undefined) => {
-				const res = await client.execute(sql, params);
-				return res[0] as any;
-			},
-		},
-		schema,
-	);
-
-	const file = schemaToTypeScriptSingleStore(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/singlestore/${testName}.ts`, file.file);
-
-	const response = await prepareFromSingleStoreImports([
-		`tests/introspect/singlestore/${testName}.ts`,
-	]);
-
-	const afterFileImports = generateSingleStoreSnapshot(
-		response.tables,
-		/* response.views, */
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashSingleStoreScheme(sch2);
-	const validatedCurAfterImport = singlestoreSchema.parse(sch2);
-
-	const leftTables = Object.values(initSchema).filter((it) => is(it, SingleStoreTable)) as SingleStoreTable[];
-
-	const initSnapshot = generateSingleStoreSnapshot(
-		leftTables,
-		/* response.views, */
-		casing,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = initSnapshot;
-
-	const initSch = {
-		version: '1',
-		dialect: 'singlestore',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashSingleStoreScheme(initSch);
-	const validatedCur = singlestoreSchema.parse(initSch);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applySingleStoreSnapshotsDiff(
-		sn2AfterIm,
-		initSn,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		/* testViewsResolverSingleStore(new Set()), */
-		validatedCurAfterImport,
-		validatedCur,
-	);
-
-	fs.rmSync(`tests/introspect/singlestore/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
-
-export const introspectSQLiteToFile = async (
-	client: Database,
-	initSchema: SqliteSchema,
-	testName: string,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applySqliteDiffs(initSchema);
-	for (const st of sqlStatements) {
-		client.exec(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromSqliteDatabase(
-		{
-			query: async <T>(sql: string, params: any[] = []) => {
-				return client.prepare(sql).bind(params).all() as T[];
-			},
-			run: async (query: string) => {
-				client.prepare(query).run();
-			},
-		},
-		undefined,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
-
-	const initSch = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashSqliteScheme(initSch);
-
-	const validatedCur = sqliteSchema.parse(initSch);
-
-	const file = schemaToTypeScriptSQLite(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/sqlite/${testName}.ts`, file.file);
-
-	const response = await prepareFromSqliteImports([
-		`tests/introspect/sqlite/${testName}.ts`,
-	]);
-
-	const afterFileImports = generateSqliteSnapshot(
-		response.tables,
-		response.views,
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashSqliteScheme(sch2);
-	const validatedCurAfterImport = sqliteSchema.parse(sch2);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applySqliteSnapshotsDiff(
-		sn2AfterIm,
-		initSn,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverSqlite(new Set()),
-		validatedCurAfterImport,
-		validatedCur,
-	);
-
-	fs.rmSync(`tests/introspect/sqlite/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};
-
-export const introspectLibSQLToFile = async (
-	client: Client,
-	initSchema: SqliteSchema,
-	testName: string,
-	casing?: CasingType | undefined,
-) => {
-	// put in db
-	const { sqlStatements } = await applyLibSQLDiffs(initSchema);
-	for (const st of sqlStatements) {
-		client.execute(st);
-	}
-
-	// introspect to schema
-	const introspectedSchema = await fromSqliteDatabase(
-		{
-			query: async <T>(sql: string, params: any[] = []) => {
-				return (await client.execute({ sql, args: params })).rows as T[];
-			},
-			run: async (query: string) => {
-				client.execute(query);
-			},
-		},
-		undefined,
-	);
-
-	const { version: initV, dialect: initD, ...initRest } = introspectedSchema;
-
-	const initSch = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...initRest,
-	} as const;
-
-	const initSn = squashSqliteScheme(initSch);
-
-	const validatedCur = sqliteSchema.parse(initSch);
-
-	const file = schemaToTypeScriptSQLite(introspectedSchema, 'camel');
-
-	fs.writeFileSync(`tests/introspect/libsql/${testName}.ts`, file.file);
-
-	const response = await prepareFromSqliteImports([
-		`tests/introspect/libsql/${testName}.ts`,
-	]);
-
-	const afterFileImports = generateSqliteSnapshot(
-		response.tables,
-		response.views,
-		casing,
-	);
-
-	const { version: v2, dialect: d2, ...rest2 } = afterFileImports;
-
-	const sch2 = {
-		version: '6',
-		dialect: 'sqlite',
-		id: '0',
-		prevId: '0',
-		...rest2,
-	} as const;
-
-	const sn2AfterIm = squashSqliteScheme(sch2);
-	const validatedCurAfterImport = sqliteSchema.parse(sch2);
-
-	const {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	} = await applyLibSQLSnapshotsDiff(
-		sn2AfterIm,
-		initSn,
-		testTablesResolver(new Set()),
-		testColumnsResolver(new Set()),
-		testViewsResolverSqlite(new Set()),
-		validatedCurAfterImport,
-		validatedCur,
-	);
-
-	fs.rmSync(`tests/introspect/libsql/${testName}.ts`);
-
-	return {
-		sqlStatements: afterFileSqlStatements,
-		statements: afterFileStatements,
-	};
-};