fix(mysql): optimize stored procedure loading

This commit is contained in:
zipg authored and GitHub committed 2026-07-11 00:32:49 +08:00
1 parent 16d7aef4db
commit 3a5ef776b1
6 files changed
+424 -112

No files matched your search

@@ -1,6 +1,6 @@
import { createPinia, setActivePinia } from "pinia";
import { beforeEach, describe, expect, it, vi } from "vitest";
import type { ConnectionConfig, TableInfo, TreeNode } from "@/types/database";
import type { ConnectionConfig, ObjectInfo, TableInfo, TreeNode } from "@/types/database";
function installLocalStorage() {
const data = new Map<string, string>();
@@ -24,6 +24,32 @@ function postgresConnection(): ConnectionConfig {
} as ConnectionConfig;
}
function mysqlConnection(): ConnectionConfig {
return {
id: "mysql-1",
name: "MySQL",
db_type: "mysql",
host: "127.0.0.1",
port: 3306,
username: "root",
password: "",
database: "app",
} as ConnectionConfig;
}
function procedure(name: string): ObjectInfo {
return {
name,
object_type: "PROCEDURE",
schema: "app",
comment: null,
created_at: null,
updated_at: null,
parent_schema: null,
parent_name: null,
};
}
describe("connectionStore metadata loading", () => {
beforeEach(() => {
vi.resetModules();
@@ -96,4 +122,88 @@ describe("connectionStore metadata loading", () => {
expect(listObjects).toHaveBeenCalled();
expect(schemaNode.children?.map((node) => node.label)).toEqual(["users"]);
});
it("paginates procedure groups and appends the next page", async () => {
const firstPage = Array.from({ length: 201 }, (_, index) => procedure(`p_${String(index + 1).padStart(4, "0")}`));
const listObjects = vi
.fn()
.mockResolvedValueOnce(firstPage)
.mockResolvedValueOnce([procedure("p_0201"), procedure("p_0202")])
.mockResolvedValueOnce([procedure("p_0999")]);
vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));
vi.doMock("@/lib/backend/api", () => ({
checkConnectionHealth: vi.fn().mockResolvedValue(undefined),
deleteSchemaCachePrefix: vi.fn().mockResolvedValue(undefined),
listObjects,
loadSchemaCache: vi.fn().mockResolvedValue(null),
saveSchemaCache: vi.fn().mockResolvedValue(undefined),
saveConnections: vi.fn().mockResolvedValue(undefined),
saveSidebarLayout: vi.fn().mockResolvedValue(undefined),
}));
const { useConnectionStore } = await import("@/stores/connectionStore");
const { useSettingsStore } = await import("@/stores/settingsStore");
const store = useConnectionStore();
const settingsStore = useSettingsStore();
settingsStore.editorSettings.sidebarObjectDisplay = "grouped";
settingsStore.desktopSettings.sidebar_table_page_size = 200;
const connection = mysqlConnection();
const procedureGroup: TreeNode = {
id: "mysql-1:app:__procedures",
label: "tree.procedures",
type: "group-procedures",
connectionId: connection.id,
database: "app",
isExpanded: false,
children: [],
};
store.connections = [connection];
store.connectedIds.add(connection.id);
store.treeNodes = [
{
id: connection.id,
label: connection.name,
type: "connection",
connectionId: connection.id,
isExpanded: true,
children: [
{
id: "mysql-1:app",
label: "app",
type: "database",
connectionId: connection.id,
database: "app",
isExpanded: true,
children: [procedureGroup],
},
],
},
];
const storedProcedureGroup = store.treeNodes[0].children?.[0].children?.[0];
expect(storedProcedureGroup?.type).toBe("group-procedures");
await store.loadObjectGroupChildren(storedProcedureGroup!);
expect(listObjects).toHaveBeenNthCalledWith(1, connection.id, "app", "app", ["PROCEDURE"], undefined, 201, 0);
expect(storedProcedureGroup?.children).toHaveLength(201);
expect(storedProcedureGroup?.children?.[0].label).toBe("p_0001");
expect(storedProcedureGroup?.children?.[199].label).toBe("p_0200");
expect(storedProcedureGroup?.children?.[200].label).toBe("tree.loadMore");
const loadMoreNode = storedProcedureGroup?.children?.at(-1);
expect(loadMoreNode?.type).toBe("load-more");
await store.loadMoreObjectGroupChildren(loadMoreNode!);
expect(listObjects).toHaveBeenNthCalledWith(2, connection.id, "app", "app", ["PROCEDURE"], undefined, 201, 200);
expect(storedProcedureGroup?.children).toHaveLength(202);
expect(storedProcedureGroup?.children?.at(-1)?.label).toBe("p_0202");
store.sidebarSearchQuery = "p_0999";
await store.loadObjectGroupChildren(storedProcedureGroup!, { force: true, searchFilter: "p_0999" });
expect(listObjects).toHaveBeenNthCalledWith(3, connection.id, "app", "app", ["PROCEDURE"], "p_0999", undefined, undefined);
expect(storedProcedureGroup?.children?.map((node) => node.label)).toEqual(["p_0999"]);
});
});
+93 -32
View File
@@ -1206,6 +1206,56 @@ export const useConnectionStore = defineStore("connection", () => {
};
}
async function loadPagedObjectGroupChildren(options: {
node: TreeNode;
parentNodeId: string;
querySchema: string;
effectiveSchema?: string;
objectTypes: DatabaseObjectTreeKind[];
offset: number;
pageSize: number;
searchFilter?: string;
force?: boolean;
}): Promise<{ children: TreeNode[]; objectCount: number; hasMore: boolean; nextOffset: number }> {
if (!options.node.connectionId || !options.node.database) {
return { children: [], objectCount: 0, hasMore: false, nextOffset: options.offset };
}
const searchFilter = options.searchFilter || undefined;
const fetchLimit = searchFilter ? undefined : options.pageSize + 1;
const fetchOffset = searchFilter ? undefined : options.offset;
const objects = await loadCachedMetadataListPage<ObjectInfo[]>(
metadataListCacheScope({
kind: "object-list-page",
connectionId: options.node.connectionId,
database: options.node.database,
schema: options.querySchema,
nodeKind: options.node.type,
objectTypes: options.objectTypes,
searchFilter,
limit: fetchLimit,
offset: fetchOffset,
sidebarDisplayMode: useSettingsStore().editorSettings.sidebarObjectDisplay,
}),
() => api.listObjects(options.node.connectionId!, options.node.database!, options.querySchema, options.objectTypes, searchFilter, fetchLimit, fetchOffset),
{ force: options.force },
);
const hasMore = searchFilter ? false : objects.length > options.pageSize;
const pageObjects = hasMore ? objects.slice(0, options.pageSize) : objects;
const children = objectGroupChildrenFromObjects({
node: options.node,
parentNodeId: options.parentNodeId,
effectiveSchema: options.effectiveSchema,
objectTypes: options.objectTypes,
objects: pageObjects,
});
return {
children,
objectCount: children.length,
hasMore,
nextOffset: options.offset + pageObjects.length,
};
}
async function loadPagedSimpleTableChildren(options: {
nodeId: string;
connectionId: string;
@@ -3003,6 +3053,7 @@ export const useConnectionStore = defineStore("connection", () => {
async function loadObjectGroupChildren(node: TreeNode, options?: LoadTreeOptions) {
const configForScope = node.connectionId ? getConfig(node.connectionId) : undefined;
const objectTypesForScope = objectTypesForGroupNode(node.type);
const pageSizeForScope = sidebarObjectGroupPageSize();
return runTreeMetadataLoad(
{
kind: "object-group",
@@ -3012,7 +3063,7 @@ export const useConnectionStore = defineStore("connection", () => {
nodeKind: node.type,
objectTypes: objectTypesForScope,
searchFilter: activeTreeLoadSearchFilter(options),
limit: sidebarObjectGroupPageSize() + 1,
limit: pageSizeForScope + 1,
offset: 0,
sidebarDisplayMode: useSettingsStore().editorSettings.sidebarObjectDisplay,
driverProfile: metadataDriverProfile(configForScope),
@@ -3060,28 +3111,20 @@ export const useConnectionStore = defineStore("connection", () => {
children = page.hasMore && !searchFilter ? appendTableTreeLoadMoreNode(page.children, buildLoadMoreNode(node, page.nextOffset, sidebarObjectGroupPageSize()), page.loadMoreParent) : page.children;
nextObjectCount = page.objectCount;
} else {
const objects = await loadCachedMetadataListPage<ObjectInfo[]>(
metadataListCacheScope({
kind: "object-list-page",
connectionId: node.connectionId,
database: node.database,
schema: querySchema,
nodeKind: node.type,
objectTypes,
searchFilter: searchFilter || undefined,
sidebarDisplayMode: useSettingsStore().editorSettings.sidebarObjectDisplay,
}),
() => api.listObjects(node.connectionId!, node.database!, querySchema, objectTypes, searchFilter || undefined),
{ force: options?.force },
);
children = objectGroupChildrenFromObjects({
const pageSize = sidebarObjectGroupPageSize();
const page = await loadPagedObjectGroupChildren({
node,
parentNodeId,
querySchema,
effectiveSchema,
objectTypes,
objects,
offset: 0,
pageSize,
searchFilter: searchFilter || undefined,
force: options?.force,
});
nextObjectCount = children.length;
children = page.hasMore && !searchFilter ? [...page.children, buildLoadMoreNode(node, page.nextOffset, pageSize)] : page.children;
nextObjectCount = page.objectCount;
}
if (isTreeLoadSearchChanged(searchFilter, options)) return;
if (!canApplyTreeMetadataResult(node)) return;
@@ -3186,26 +3229,44 @@ export const useConnectionStore = defineStore("connection", () => {
const objectTypes = objectTypesForGroupNode(parent.type);
const parentNodeId = objectGroupRefreshParentId(parent);
if (!objectTypes || !parentNodeId) return;
if (!objectTypes.every((objectType) => objectType === "TABLE" || objectType === "VIEW" || objectType === "MATERIALIZED_VIEW")) return;
const config = getConfig(parentConnectionId);
const parentDatabase = parent.database;
if (!parentDatabase) return;
const querySchema = connectionObjectTreeQuerySchema(config, parentDatabase, parent.schema);
const effectiveSchema = connectionObjectTreeNodeSchema(config, parentDatabase, parent.schema);
const page = await loadPagedTableGroupChildren({
node: parent,
parentNodeId,
querySchema,
effectiveSchema,
objectTypes,
offset: loadMore.offset,
pageSize: loadMore.pageSize,
force: false,
});
const currentChildren = withoutTableTreeLoadMoreNodes(parent.children);
const mergedChildren = mergeTableTreePageChildren(currentChildren, page.children, parentConnectionId, parentDatabase);
const nextChildren = page.hasMore ? appendTableTreeLoadMoreNode(mergedChildren, buildLoadMoreNode(parent, page.nextOffset, loadMore.pageSize), page.loadMoreParent) : mergedChildren;
const wantsOnlyTablesOrViews = objectTypes.every((objectType) => objectType === "TABLE" || objectType === "VIEW" || objectType === "MATERIALIZED_VIEW");
let mergedChildren: TreeNode[];
let nextChildren: TreeNode[];
if (wantsOnlyTablesOrViews) {
const page = await loadPagedTableGroupChildren({
node: parent,
parentNodeId,
querySchema,
effectiveSchema,
objectTypes,
offset: loadMore.offset,
pageSize: loadMore.pageSize,
force: false,
});
const currentChildren = withoutTableTreeLoadMoreNodes(parent.children);
mergedChildren = mergeTableTreePageChildren(currentChildren, page.children, parentConnectionId, parentDatabase);
nextChildren = page.hasMore ? appendTableTreeLoadMoreNode(mergedChildren, buildLoadMoreNode(parent, page.nextOffset, loadMore.pageSize), page.loadMoreParent) : mergedChildren;
} else {
const page = await loadPagedObjectGroupChildren({
node: parent,
parentNodeId,
querySchema,
effectiveSchema,
objectTypes,
offset: loadMore.offset,
pageSize: loadMore.pageSize,
force: false,
});
const currentChildren = withoutLoadMoreNodes(parent.children);
mergedChildren = mergeLocatedTreeChildren(parent, currentChildren, page.children, parentConnectionId, parentDatabase);
nextChildren = page.hasMore ? [...mergedChildren, buildLoadMoreNode(parent, page.nextOffset, loadMore.pageSize)] : mergedChildren;
}
if (!canApplyTreeMetadataResult(parent)) return;
parent.objectCount = mergedChildren.length;
setChildren(parent, nextChildren);