fix(schema-diff): fan out metadata by sqlserver capacity

This commit is contained in:
jearhe authored and GitHub committed 2026-09-20 01:28:49 +08:00
1 parent 8b757b97bc
commit dc6c9b5c7c
2 files changed
+477 -19

No files matched your search

@@ -1,5 +1,15 @@
import { describe, expect, it } from "vitest";
import { createConcurrencyLimiter, loadSchemaDetails, mapWithConcurrency, schemaDiffMetadataConcurrency, schemaDiffMetadataLoadPlan, shouldFetchSchemaDiffDdl, type SchemaDiffMetadataApi, type SchemaDiffMetadataProgress } from "../../schema/schemaDiffMetadataLoad";
import {
createConcurrencyLimiter,
loadSchemaDetails,
mapWithConcurrency,
schemaDiffMetadataConcurrency,
schemaDiffMetadataLaneCountForTests,
schemaDiffMetadataLoadPlan,
shouldFetchSchemaDiffDdl,
type SchemaDiffMetadataApi,
type SchemaDiffMetadataProgress,
} from "../../schema/schemaDiffMetadataLoad";
import { getSchemaDiffNextProgressStep, shouldLoadSchemaDiffExtraObjectPhase, shouldLoadSchemaDiffExtraObjects, shouldLoadSchemaDiffRoutines } from "../../schema/schemaDiffProgress";
import { DEFAULT_MYSQL_OPTIONS, DEFAULT_POSTGRES_OPTIONS } from "../../../types/schemaDiff";
import type { TableInfo } from "../../../types/database";
@@ -8,6 +18,80 @@ function wait(ms: number) {
return new Promise<void>((resolve) => setTimeout(resolve, ms));
}
const METADATA_POOL_BUSY = "DBX metadata pool is busy; please retry";
/**
* Mirrors the backend metadata gate (`crates/dbx-core/src/connection/mod.rs`):
* at most `capacity` in-flight metadata requests per gate key, and any request
* that cannot start is what `METADATA_POOL_ACQUIRE_TIMEOUT` (5s) reports as
* `DBX metadata pool is busy; please retry`.
*
* The fake rejects waiting requests instead of modelling the 5s wait, which is
* the conservative side of the real timeout: a test that passes here proves the
* caller never queues on the gate at all, not merely that it waits less than
* five seconds.
*/
function createMetadataGate(capacity: number) {
const active = new Map<string, number>();
let peak = 0;
return {
peak: () => peak,
async run<T>(key: string, task: () => Promise<T>): Promise<T> {
const current = active.get(key) ?? 0;
if (current >= capacity) throw new Error(METADATA_POOL_BUSY);
active.set(key, current + 1);
peak = Math.max(peak, current + 1);
try {
return await task();
} finally {
active.set(key, (active.get(key) ?? 1) - 1);
}
},
};
}
/**
* Wraps a metadata API in the backend gate above. The key matches
* `metadata_gate_key`: connection id plus database (SQL Server ignores the
* client session id there).
*/
function gateMetadataApi(gate: ReturnType<typeof createMetadataGate>, delays: { ddl: number; metadata: number }) {
let inFlight = 0;
let inFlightPeak = 0;
let calls = 0;
const key = (connectionId: string, database: string) => `${connectionId}\u0000${database}`;
const run = <T>(connectionId: string, database: string, delay: number, task: () => T) =>
gate.run(key(connectionId, database), async () => {
inFlight += 1;
inFlightPeak = Math.max(inFlightPeak, inFlight);
calls += 1;
try {
// `0` means "no artificial latency": the fake gate decides admission
// synchronously, so the fan-out model under test does not depend on a
// timer, and a large-scale case can skip hundreds of sequential timers.
if (delay > 0) await wait(delay);
return task();
} finally {
inFlight -= 1;
}
});
const api: SchemaDiffMetadataApi = {
getTableDdl: (connectionId, database, _schema, table) => run(connectionId, database, delays.ddl, () => `ddl:${table}`),
getColumns: (connectionId, database) => run(connectionId, database, delays.metadata, () => []),
listIndexes: (connectionId, database) => run(connectionId, database, delays.metadata, () => []),
listForeignKeys: (connectionId, database) => run(connectionId, database, delays.metadata, () => []),
listTriggers: (connectionId, database) => run(connectionId, database, delays.metadata, () => []),
};
return { api, inFlightPeak: () => inFlightPeak, calls: () => calls };
}
function sqlserverTables(...names: string[]): TableInfo[] {
return names.map((name) => ({ name, table_type: "TABLE" }) as TableInfo);
}
describe("schemaDiffMetadataLoad", () => {
it("uses adaptive metadata concurrency for MySQL-compatible databases", () => {
expect(schemaDiffMetadataConcurrency("mysql")).toBe(2);
@@ -20,6 +104,277 @@ describe("schemaDiffMetadataLoad", () => {
expect(schemaDiffMetadataConcurrency(undefined)).toBe(6);
});
it("uses one serialized metadata request for SQL Server", () => {
// The backend gate admits `METADATA_POOL_SQLSERVER_LIMIT = 1` in-flight
// request per (connection, database) and both SQL Server pools hold one
// serialized session, so any extra fan-out only queues until it fails.
// Native and `sqlserver-legacy` share one dbType and one limit, so there is
// no driver-profile branch to make here.
expect(schemaDiffMetadataConcurrency("sqlserver")).toBe(1);
expect(schemaDiffMetadataConcurrency("SQLServer", 12)).toBe(1);
expect(schemaDiffMetadataConcurrency("sqlserver", 500)).toBe(1);
});
it("keeps SQL Server metadata fan-out inside the backend gate", async () => {
const gate = createMetadataGate(1);
const { api, inFlightPeak } = gateMetadataApi(gate, { ddl: 4, metadata: 1 });
const details = await loadSchemaDetails(
sqlserverTables("orders", "customers", "events", "invoices", "items", "audit"),
{
connectionId: "9596-fanout",
database: "app",
schema: "dbo",
dbType: "sqlserver",
// SQL Server falls back to the PostgreSQL option tree today
// (`getSchemaDiffOptionsForDbType`), which fetches DDL for every table.
options: { ...DEFAULT_POSTGRES_OPTIONS },
},
api,
);
expect(details.map((detail) => detail.name)).toEqual(["orders", "customers", "events", "invoices", "items", "audit"]);
expect(details.map((detail) => detail.ddl)).toEqual(["ddl:orders", "ddl:customers", "ddl:events", "ddl:invoices", "ddl:items", "ddl:audit"]);
expect(gate.peak()).toBe(1);
expect(inFlightPeak()).toBe(1);
});
it("keeps a large SQL Server schema inside the metadata gate", async () => {
// Regression for #9596 at the reporter's scale: compares over a handful of
// tables succeed there, while "more than 100 tables" reproduces
// `DBX metadata pool is busy` every time. 100 is a field observation, not
// a code threshold -- the failure comes from the 6-wide fan-out queueing on
// a capacity-1 resource, and a bigger schema adds metadata volume, tail
// latency and time windows where other metadata work shares the same
// permit. So this case scales the workload instead of special-casing a
// table count: the capacity fix has to hold for a realistically large
// schema, not only for the six tables above.
const tableCount = 120;
const tables = sqlserverTables(...Array.from({ length: tableCount }, (_, index) => `table_${String(index).padStart(3, "0")}`));
const gate = createMetadataGate(1);
// No artificial latency: the fake gate decides admission synchronously, so
// a 6-wide fan-out still trips it on the first burst, while 600 sequential
// timers would only add wall clock (`setTimeout(1)` costs ~15ms on
// Windows).
const { api, inFlightPeak, calls } = gateMetadataApi(gate, { ddl: 0, metadata: 0 });
const details = await loadSchemaDetails(
tables,
{
connectionId: "9596-large-schema",
database: "app",
schema: "dbo",
dbType: "sqlserver",
options: { ...DEFAULT_POSTGRES_OPTIONS },
},
api,
);
expect(details).toHaveLength(tableCount);
expect(details.every((detail) => detail.ddl === `ddl:${detail.name}`)).toBe(true);
// 5 metadata requests per table (DDL + columns + indexes + foreign keys +
// triggers), every one of them admitted by a single capacity-1 permit.
expect(calls()).toBe(tableCount * 5);
expect(gate.peak()).toBe(1);
expect(inFlightPeak()).toBe(1);
});
it("would trip the SQL Server metadata gate at the fan-out used before the fix", async () => {
const gate = createMetadataGate(1);
const runFanOut = createConcurrencyLimiter(6);
await expect(Promise.all(Array.from({ length: 6 }, () => runFanOut(() => gate.run("9596-fanout\u0000app", () => wait(1)))))).rejects.toThrow(METADATA_POOL_BUSY);
});
it("keeps SQL Server schema compare source and target databases inside the gate", async () => {
const gate = createMetadataGate(1);
const { api } = gateMetadataApi(gate, { ddl: 3, metadata: 1 });
const context = (database: string) => ({
connectionId: "9596-same-connection",
database,
schema: "dbo",
dbType: "sqlserver",
options: { ...DEFAULT_POSTGRES_OPTIONS },
});
const tables = sqlserverTables("orders", "customers", "events");
const source = await loadSchemaDetails(tables, context("app_source"), api);
const target = await loadSchemaDetails(tables, context("app_target"), api);
expect(source).toHaveLength(3);
expect(target).toHaveLength(3);
expect(gate.peak()).toBe(1);
});
it("queues concurrent SQL Server compares on one metadata resource instead of failing on the gate", async () => {
const gate = createMetadataGate(1);
const { api } = gateMetadataApi(gate, { ddl: 4, metadata: 1 });
const context = {
connectionId: "9596-background",
database: "app",
schema: "dbo",
dbType: "sqlserver",
options: { ...DEFAULT_POSTGRES_OPTIONS },
};
const tables = sqlserverTables("orders", "customers", "events", "invoices");
const [foreground, background] = await Promise.all([loadSchemaDetails(tables, context, api), loadSchemaDetails(tables, context, api)]);
expect(foreground).toHaveLength(4);
expect(background).toHaveLength(4);
expect(gate.peak()).toBe(1);
});
it("keeps one shared lane for a compare starting after another compare's first table", async () => {
// Regression: the lane used to be evicted by the limiter's idle callback,
// which at SQL Server's concurrency of 1 fires at every table boundary --
// mid-compare. A compare starting there built a second 1-wide lane, and the
// two fan-outs together overran the backend's capacity-1 gate with
// `DBX metadata pool is busy`. The lane must instead live as long as the
// compares actively using it hold it.
const gate = createMetadataGate(1);
const { api } = gateMetadataApi(gate, { ddl: 4, metadata: 1 });
const context = {
connectionId: "9596-mid-flight",
database: "app",
schema: "dbo",
dbType: "sqlserver",
options: { ...DEFAULT_POSTGRES_OPTIONS },
};
const tables = sqlserverTables("orders", "customers", "events", "invoices");
let resolvePastFirstTable!: () => void;
const pastFirstTable = new Promise<void>((resolve) => {
resolvePastFirstTable = resolve;
});
const first = loadSchemaDetails(
tables,
{
...context,
onProgress: (value) => {
if (value.current >= 2) resolvePastFirstTable();
},
},
api,
);
await pastFirstTable;
// The first compare is past a table boundary, exactly where the old
// idle-based eviction had already removed its lane mid-compare.
expect(schemaDiffMetadataLaneCountForTests()).toBe(1);
const second = loadSchemaDetails(tables, context, api);
const [firstDetails, secondDetails] = await Promise.all([first, second]);
expect(firstDetails).toHaveLength(4);
expect(secondDetails).toHaveLength(4);
expect(gate.peak()).toBe(1);
expect(schemaDiffMetadataLaneCountForTests()).toBe(0);
});
it("does not pin the metadata lane when the table list is empty", async () => {
// An empty compare (a filter that matches nothing) never runs a metadata
// request, so limiter activity alone can never free the lane. The call's
// own hold must release it, or the lane stays pinned in the map forever.
const gate = createMetadataGate(1);
const { api, calls } = gateMetadataApi(gate, { ddl: 0, metadata: 0 });
const details = await loadSchemaDetails(
[],
{
connectionId: "9596-empty-tables",
database: "app",
schema: "dbo",
dbType: "sqlserver",
options: { ...DEFAULT_POSTGRES_OPTIONS },
},
api,
);
expect(details).toEqual([]);
expect(calls()).toBe(0);
expect(schemaDiffMetadataLaneCountForTests()).toBe(0);
});
it("keeps the lane alive until a failed compare's queued requests drain", async () => {
// A failed compare stops awaiting requests it already queued: its
// `Promise.all` rejects while the remaining requests keep running on the
// lane. Those orphans must keep the lane in the map so an immediate retry
// shares it instead of racing the orphans on the gate with a second lane.
let active = 0;
let peak = 0;
const track = async <T>(task: () => Promise<T>) => {
active += 1;
peak = Math.max(peak, active);
try {
return await task();
} finally {
active -= 1;
}
};
const api: SchemaDiffMetadataApi = {
getTableDdl: async (_connectionId, _database, _schema, table) =>
track(async () => {
await wait(6);
return `ddl:${table}`;
}),
getColumns: async () => {
throw new Error("columns failed");
},
listIndexes: async () =>
track(async () => {
await wait(6);
return [];
}),
listForeignKeys: async () =>
track(async () => {
await wait(6);
return [];
}),
listTriggers: async () =>
track(async () => {
await wait(6);
return [];
}),
};
const context = {
connectionId: "9596-orphan-drain",
database: "app",
schema: "dbo",
dbType: "sqlserver",
options: { ...DEFAULT_POSTGRES_OPTIONS },
};
const tables = sqlserverTables("orders", "customers");
await expect(loadSchemaDetails(tables, context, api)).rejects.toThrow("columns failed");
// The compare has failed, but its queued index/key/trigger requests are
// still draining behind it: the lane must still exist for the retry.
expect(schemaDiffMetadataLaneCountForTests()).toBe(1);
await expect(loadSchemaDetails(tables, context, api)).rejects.toThrow("columns failed");
for (let attempt = 0; attempt < 100 && schemaDiffMetadataLaneCountForTests() > 0; attempt += 1) await wait(1);
expect(schemaDiffMetadataLaneCountForTests()).toBe(0);
expect(peak).toBe(1);
});
it("keeps SQL Server metadata lanes independent per database", async () => {
const gate = createMetadataGate(1);
const { api, inFlightPeak } = gateMetadataApi(gate, { ddl: 4, metadata: 1 });
const context = (database: string) => ({
connectionId: "9596-lanes",
database,
schema: "dbo",
dbType: "sqlserver",
options: { ...DEFAULT_POSTGRES_OPTIONS },
});
const tables = sqlserverTables("orders", "customers");
await Promise.all([loadSchemaDetails(tables, context("app_a"), api), loadSchemaDetails(tables, context("app_b"), api)]);
expect(gate.peak()).toBe(1);
expect(inFlightPeak()).toBe(2);
});
it("skips view DDL when views are disabled while preserving table DDL options", () => {
expect(shouldFetchSchemaDiffDdl(true, { tables: true, views: false })).toBe(false);
expect(shouldFetchSchemaDiffDdl(true, { tables: false, views: true })).toBe(true);