Merge branch 'alternation-engine' of https://github.com/drizzle-team/drizzle-orm into alternation-engine

Author: Sukairo-02

drizzle-kit/src/dialects/drizzle.ts

@@ -34,7 +34,6 @@ export const extractPostgresExisting = (
 		schema: x.schema ?? 'public',
 		name: x.name,
 	}));
-
 	const existingMatViews = matViews.map((x) => pgMatViewConfig(x)).filter((x) => x.isExisting).map<Table>((
 		x,
 	) => ({

drizzle-kit/src/dialects/postgres/drizzle.ts

@@ -667,7 +667,7 @@ export const fromDrizzleSchema = (
 	});
 
 	for (const view of combinedViews) {
-		if (view.isExisting) continue;
+		if (view.isExisting || !filter({ type: 'table', schema: view.schema ?? 'public', name: view.name })) continue;
 
 		const {
 			name: viewName,

drizzle-kit/src/dialects/postgres/introspect.ts

@@ -146,7 +146,7 @@ export const fromDatabase = async (
 		defaultsQuery,
 	]);
 
-	const { other } = namespaces.reduce<{ system: Namespace[]; other: Namespace[] }>(
+	const { other: filteredNamespaces } = namespaces.reduce<{ system: Namespace[]; other: Namespace[] }>(
 		(acc, it) => {
 			if (isSystemNamespace(it.name)) {
 				acc.system.push(it);
@@ -158,7 +158,6 @@ export const fromDatabase = async (
 		{ system: [], other: [] },
 	);
 
-	const filteredNamespaces = other.filter((it) => filter({ type: 'schema', name: it.name }));
 	const filteredNamespacesStringForSQL = filteredNamespaces.map((ns) => `'${ns.name}'`).join(',');
 
 	schemas.push(...filteredNamespaces.map<Schema>((it) => ({ entityType: 'schemas', name: it.name })));
@@ -209,19 +208,13 @@ export const fromDatabase = async (
 		: [] as TableListItem[];
 
 	const viewsList = tablesList.filter((it) => {
-		if ((it.kind === 'v' || it.kind === 'm')) {
-			return filter({ type: 'table', schema: it.schema, name: it.name });
-		}
-		return false;
+		it.schema = trimChar(it.schema, '"'); // when camel case name e.x. mySchema -> it gets wrapped to "mySchema"
+		return it.kind === 'v' || it.kind === 'm';
 	});
 
 	const filteredTables = tablesList.filter((it) => {
 		it.schema = trimChar(it.schema, '"'); // when camel case name e.x. mySchema -> it gets wrapped to "mySchema"
-
-		if ((it.kind === 'r' || it.kind === 'p')) {
-			return filter({ type: 'table', schema: it.schema, name: it.name });
-		}
-		return false;
+		return it.kind === 'r' || it.kind === 'p';
 	});
 
 	const filteredTableIds = filteredTables.map((it) => it.oid);
@@ -681,10 +674,7 @@ export const fromDatabase = async (
 
 	progressCallback('enums', Object.keys(groupedEnums).length, 'done');
 
-	// TODO: drizzle link
-	const filteredRoles = rolesList.filter((x) => filter({ type: 'role', name: x.rolname }));
-
-	for (const dbRole of filteredRoles) {
+	for (const dbRole of rolesList) {
 		roles.push({
 			entityType: 'roles',
 			name: dbRole.rolname,
@@ -1205,22 +1195,39 @@ export const fromDatabase = async (
 	progressCallback('checks', checksCount, 'done');
 	progressCallback('views', viewsCount, 'done');
 
+	const resultSchemas = schemas.filter((x) => filter({ type: 'schema', name: x.name }));
+	const resultTables = tables.filter((x) => filter({ type: 'table', schema: x.schema, name: x.name }));
+	const resultEnums = enums.filter((x) => resultSchemas.some((s) => s.name === x.schema));
+	const resultColumns = columns.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultIndexes = indexes.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultPKs = pks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultFKs = fks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultUniques = uniques.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultChecks = checks.filter((x) => resultTables.some((t) => t.schema === x.schema && t.name === x.table));
+	const resultSequences = sequences.filter((x) => resultSchemas.some((t) => t.name === x.schema));
+	// TODO: drizzle link
+	const resultRoles = roles.filter((x) => filter({ type: 'role', name: x.name }));
+	const resultViews = views.filter((x) => filter({ type: 'table', schema: x.schema, name: x.name }));
+	const resultViewColumns = viewColumns.filter((x) =>
+		resultViews.some((v) => v.schema === x.schema && v.name === x.view)
+	);
+
 	return {
-		schemas,
-		tables,
-		enums,
-		columns,
-		indexes,
-		pks,
-		fks,
-		uniques,
-		checks,
-		sequences,
-		roles,
+		schemas: resultSchemas,
+		tables: resultTables,
+		enums: resultEnums,
+		columns: resultColumns,
+		indexes: resultIndexes,
+		pks: resultPKs,
+		fks: resultFKs,
+		uniques: resultUniques,
+		checks: resultChecks,
+		sequences: resultSequences,
+		roles: resultRoles,
 		privileges,
 		policies,
-		views,
-		viewColumns,
+		views: resultViews,
+		viewColumns: resultViewColumns,
 	} satisfies InterimSchema;
 };
 

drizzle-kit/src/dialects/pull-utils.ts

@@ -6,6 +6,17 @@ import type { Dialect } from 'src/utils/schemaValidator';
 export type Schema = { type: 'schema'; name: string };
 export type Table = { type: 'table'; schema: string | false; name: string };
 export type Role = { type: 'role'; name: string };
+
+/*
+	there's a double edge sword with having narrow list here
+	on one hand we can filter other entities through these 3 types
+
+	on the other hand when debugged - you see schema/table filter invocation
+	for all other types like enums, sequences, etc.
+
+	I will leave this as is and in introspect I will rely on introspected schemas and tables
+	to filter list of dependent entities, that'd probably be the go to
+*/
 export type KitEntity = Schema | Table | Role;
 
 export type EntityFilter = (it: KitEntity) => boolean;

drizzle-kit/tests/postgres/big.test.ts

@@ -0,0 +1,32 @@
+import { pgSchema } from 'drizzle-orm/pg-core';
+import { afterAll, beforeAll, beforeEach, expect, test } from 'vitest';
+import { diff, prepareTestDatabase, push, TestDatabase } from './mocks';
+
+// @vitest-environment-options {"max-concurrency":1}
+let _: TestDatabase;
+let db: TestDatabase['db'];
+
+beforeAll(async () => {
+	_ = await prepareTestDatabase();
+	db = _.db;
+});
+
+afterAll(async () => {
+	await _.close();
+});
+
+beforeEach(async () => {
+	await _.clear();
+});
+
+test('big schema #1', async () => {
+	const schema = await import('./schemas/schema1');
+
+	await push({ db, to: schema });
+
+	const res1 = await push({ db, to: { ...schema, core: pgSchema('core').existing() } });
+	expect(res1.sqlStatements).toStrictEqual([]);
+
+	const res2 = await push({ db, to: schema });
+	expect(res2.sqlStatements).toStrictEqual([]);
+});