25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(schema-diff): fan out metadata by sqlserver capacity
jearhedc6c9b5c7c5c
diff --git a/apps/desktop/src/lib/__tests__/schema/schemaDiffMetadataLoad.spec.ts b/apps/desktop/src/lib/__tests__/schema/schemaDiffMetadataLoad.spec.tsindex 84e18abf59..84a28c63da 100644--- a/apps/desktop/src/lib/__tests__/schema/schemaDiffMetadataLoad.spec.ts+++ b/apps/desktop/src/lib/__tests__/schema/schemaDiffMetadataLoad.spec.ts@@ -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);diff --git a/apps/desktop/src/lib/schema/schemaDiffMetadataLoad.ts b/apps/desktop/src/lib/schema/schemaDiffMetadataLoad.tsindex d1a4178801..2acab14d43 100644--- a/apps/desktop/src/lib/schema/schemaDiffMetadataLoad.ts+++ b/apps/desktop/src/lib/schema/schemaDiffMetadataLoad.ts@@ -8,6 +8,25 @@ const MYSQL_SMALL_SCHEMA_DIFF_METADATA_CONCURRENCY = 4;const MYSQL_SMALL_SCHEMA_TABLE_LIMIT = 30;const DEFAULT_SCHEMA_DIFF_METADATA_CONCURRENCY = 6;+/**+ * SQL Server metadata is served by a single serialized session per+ * (connection, database): the native pool holds one `Mutex<SqlServerClient>`+ * and the `sqlserver-legacy` profile holds one Agent session, while the+ * backend metadata gate admits `METADATA_POOL_SQLSERVER_LIMIT = 1` in-flight+ * request per (connection, database) and turns anything that still has to wait+ * after `METADATA_POOL_ACQUIRE_TIMEOUT` (5s) into+ * `DBX metadata pool is busy; please retry`+ * (crates/dbx-core/src/connection/mod.rs). Fanning out further cannot add+ * throughput because the backend serializes those same requests anyway; it+ * only builds a queue that is guaranteed to time out.+ *+ * Both drivers share the same limit, so this is a per-database-type metadata+ * capacity rather than a driver-capability check: `metadata_concurrency_limit`+ * returns `METADATA_POOL_SQLSERVER_LIMIT` whenever the config is `sqlserver`,+ * regardless of driver profile.+ */+const SQLSERVER_SCHEMA_DIFF_METADATA_CONCURRENCY = 1;+function normalizeConcurrencyLimit(limit: number): number {return Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 1;}@@ -20,6 +39,9 @@ export function schemaDiffMetadataConcurrency(dbType: string | null | undefined,}return MYSQL_LARGE_SCHEMA_DIFF_METADATA_CONCURRENCY;}+ if (normalizedDbType === "sqlserver") {+ return SQLSERVER_SCHEMA_DIFF_METADATA_CONCURRENCY;+ }return DEFAULT_SCHEMA_DIFF_METADATA_CONCURRENCY;}@@ -84,7 +106,7 @@ export async function mapWithConcurrency<T, R>(items: readonly T[], limit: numbereturn results;}-export function createConcurrencyLimiter(limit: number) {+export function createConcurrencyLimiter(limit: number, onIdle?: () => void) {const maxActive = normalizeConcurrencyLimit(limit);let active = 0;const queue: Array<() => void> = [];@@ -106,7 +128,11 @@ export function createConcurrencyLimiter(limit: number) {function release() {active = Math.max(0, active - 1);const next = queue.shift();- if (next) next();+ if (next) {+ next();+ return;+ }+ if (active === 0) onIdle?.();}return async function runLimited<T>(task: () => Promise<T>): Promise<T> {@@ -119,6 +145,70 @@ export function createConcurrencyLimiter(limit: number) {};}+/**+ * Schema compare metadata lanes are keyed exactly like the backend metadata+ * gate -- `(connection id, database)` -- so the fan-out limit belongs to the+ * resource instead of to one compare session. Two compares can hammer the same+ * resource at once (closing a compare dialog keeps the compare running in the+ * background) and adding their fan-out together would occupy the backend gate+ * and fail whoever loses the race with `DBX metadata pool is busy; please+ * retry`. Waiting here instead keeps the queue off the backend gate, where+ * `METADATA_POOL_ACQUIRE_TIMEOUT` (5s) would turn it into that error.+ *+ * A lane is held by every `loadSchemaDetails` call running on it: each call+ * registers itself as a holder before its first await and releases that hold+ * in a `finally`, and the lane leaves the map only once the last holder has+ * gone and every request it accepted has settled. The limiter's idle callback+ * cannot own this lifecycle: at SQL Server's concurrency of 1 the lane goes+ * idle at every table boundary, which used to evict it mid-compare so the next+ * compare built a second lane and the two 1-wide fan-outs together overran the+ * capacity-1 gate. The request count matters for the same reason on the way+ * out: a failed compare stops awaiting requests it already queued, and those+ * orphans must keep the lane alive so a retry still shares it instead of+ * racing it on the gate. An empty table list never runs a request at all, so+ * only the holder count can free its lane.+ */+interface SchemaDiffMetadataLane {+ key: string;+ run: ReturnType<typeof createConcurrencyLimiter>;+ holders: number;+ requests: number;+}++const schemaDiffMetadataLanes = new Map<string, SchemaDiffMetadataLane>();++function schemaDiffMetadataLaneKey(connectionId: string, database: string): string {+ return `${connectionId}\u0000${database}`;+}++function evictSchemaDiffMetadataLaneIfUnused(lane: SchemaDiffMetadataLane) {+ if (lane.holders <= 0 && lane.requests <= 0 && schemaDiffMetadataLanes.get(lane.key) === lane) {+ schemaDiffMetadataLanes.delete(lane.key);+ }+}++function acquireSchemaDiffMetadataLane(connectionId: string, database: string, limit: number): SchemaDiffMetadataLane {+ const key = schemaDiffMetadataLaneKey(connectionId, database);+ const existing = schemaDiffMetadataLanes.get(key);+ if (existing) {+ existing.holders += 1;+ return existing;+ }++ const lane: SchemaDiffMetadataLane = { key, run: createConcurrencyLimiter(limit), holders: 1, requests: 0 };+ schemaDiffMetadataLanes.set(key, lane);+ return lane;+}++function releaseSchemaDiffMetadataLane(lane: SchemaDiffMetadataLane) {+ lane.holders -= 1;+ evictSchemaDiffMetadataLaneIfUnused(lane);+}++export function schemaDiffMetadataLaneCountForTests(): number {+ return schemaDiffMetadataLanes.size;+}+export interface SchemaDiffMetadataApi {getTableDdl(connectionId: string, database: string, schema: string, table: string, objectType?: ObjectSourceKind): Promise<string>;getColumns(connectionId: string, database: string, schema: string, table: string): Promise<ColumnInfo[]>;@@ -155,23 +245,36 @@ function isViewOrMaterializedView(tableType: string): ObjectSourceKind | undefinexport async function loadSchemaDetails(tables: TableInfo[], context: SchemaDetailLoadContext, api: SchemaDiffMetadataApi): Promise<TableSchemaDetail[]> {const concurrency = schemaDiffMetadataConcurrency(context.dbType, tables.length);- const runMetadataQuery = createConcurrencyLimiter(concurrency);+ // Hold the lane from before the first await so a compare starting while this+ // one is between tables shares this lane instead of building a second one.+ const lane = acquireSchemaDiffMetadataLane(context.connectionId, context.database, concurrency);+ const runMetadataQuery = <T>(task: () => Promise<T>): Promise<T> => {+ lane.requests += 1;+ return lane.run(task).finally(() => {+ lane.requests -= 1;+ evictSchemaDiffMetadataLaneIfUnused(lane);+ });+ };let completed = 0;- return mapWithConcurrency(tables, concurrency, async (table) => {- const objectType = isViewOrMaterializedView(table.table_type);- const loadPlan = schemaDiffMetadataLoadPlan(isSchemaDiffView(table), context.options);- const ddlPromise = loadPlan.ddl ? runMetadataQuery(() => api.getTableDdl(context.connectionId, context.database, context.schema, table.name, objectType)) : Promise.resolve("");- const [columns, indexes, foreignKeys, triggers, ddl] = await Promise.all([- loadPlan.columns ? runMetadataQuery(() => api.getColumns(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),- loadPlan.indexes ? runMetadataQuery(() => api.listIndexes(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),- loadPlan.foreignKeys ? runMetadataQuery(() => api.listForeignKeys(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),- loadPlan.triggers ? runMetadataQuery(() => api.listTriggers(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),- ddlPromise,- ]);-- const detail = { name: table.name, columns, indexes, foreignKeys, triggers, ddl };- context.onProgress?.({ current: ++completed, total: tables.length, objectName: table.name });- return detail;- });+ try {+ return await mapWithConcurrency(tables, concurrency, async (table) => {+ const objectType = isViewOrMaterializedView(table.table_type);+ const loadPlan = schemaDiffMetadataLoadPlan(isSchemaDiffView(table), context.options);+ const ddlPromise = loadPlan.ddl ? runMetadataQuery(() => api.getTableDdl(context.connectionId, context.database, context.schema, table.name, objectType)) : Promise.resolve("");+ const [columns, indexes, foreignKeys, triggers, ddl] = await Promise.all([+ loadPlan.columns ? runMetadataQuery(() => api.getColumns(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),+ loadPlan.indexes ? runMetadataQuery(() => api.listIndexes(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),+ loadPlan.foreignKeys ? runMetadataQuery(() => api.listForeignKeys(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),+ loadPlan.triggers ? runMetadataQuery(() => api.listTriggers(context.connectionId, context.database, context.schema, table.name)) : Promise.resolve([]),+ ddlPromise,+ ]);++ const detail = { name: table.name, columns, indexes, foreignKeys, triggers, ddl };+ context.onProgress?.({ current: ++completed, total: tables.length, objectName: table.name });+ return detail;+ });+ } finally {+ releaseSchemaDiffMetadataLane(lane);+ }}