diff --git a/frontend/src/components/Sidebar.tsx b/frontend/src/components/Sidebar.tsx
index 4400e54..a5feea2 100644
--- a/frontend/src/components/Sidebar.tsx
+++ b/frontend/src/components/Sidebar.tsx
@@ -89,7 +89,11 @@ import { resolveConnectionAccentColor, resolveConnectionIconType } from '../util
 import { buildJVMTabTitle } from '../utils/jvmRuntimePresentation';
 import { buildJVMDiagnosticActionDescriptor, buildJVMMonitoringActionDescriptors } from '../utils/jvmSidebarActions';
 import { buildTableSelectQuery } from '../utils/objectQueryTemplates';
-import { buildTableExportTab } from '../utils/tableExportTab';
+import {
+    buildBatchDatabaseExportWorkbenchTab,
+    buildBatchTableExportWorkbenchTab,
+    buildTableExportTab,
+} from '../utils/tableExportTab';
 import { useExportProgressDialog } from './ExportProgressModal';
 import { getShortcutPlatform, resolveShortcutDisplay } from '../utils/shortcuts';
 import { buildExternalSQLDirectoryId, buildExternalSQLRootNode, buildExternalSQLTabId, type ExternalSQLTreeNode } from '../utils/externalSqlTree';
@@ -4024,6 +4028,30 @@ const Sidebar: React.FC<{
       setIsBatchModalOpen(true);
   };
 
+  const openBatchTableExportWorkbench = () => {
+      let connId = '';
+      let dbName = '';
+
+      if (selectedNodesRef.current.length > 0) {
+          const node = selectedNodesRef.current[0];
+          if (node.type === 'connection' && node.dataRef?.config?.type !== 'redis') {
+              connId = node.key as string;
+          } else if (node.type === 'database') {
+              connId = node.dataRef.id;
+              dbName = node.title;
+          } else if (node.type === 'table' || node.type === 'view' || node.type === 'materialized-view') {
+              connId = node.dataRef.id;
+              dbName = node.dataRef.dbName;
+          }
+      }
+
+      addTab(buildBatchTableExportWorkbenchTab({
+          connectionId: connId,
+          dbName: dbName || undefined,
+          title: dbName ? `批量导出 ${dbName} 对象` : '批量导出对象',
+      }));
+  };
+
 	  const loadDatabasesForBatch = async (conn: SavedConnection) => {
 	      const config = {
           ...conn.config,
@@ -4347,6 +4375,24 @@ const Sidebar: React.FC<{
       setIsBatchDbModalOpen(true);
   };
 
+  const openBatchDatabaseExportWorkbench = () => {
+      let connId = '';
+
+      if (selectedNodesRef.current.length > 0) {
+          const node = selectedNodesRef.current[0];
+          if (node.type === 'connection' && node.dataRef?.config?.type !== 'redis') {
+              connId = node.key as string;
+          } else if (node.type === 'database' || node.type === 'table' || node.type === 'view' || node.type === 'materialized-view') {
+              connId = node.dataRef.id;
+          }
+      }
+
+      addTab(buildBatchDatabaseExportWorkbenchTab({
+          connectionId: connId,
+          title: '批量导出库',
+      }));
+  };
+
 	  const loadDatabasesForDbBatch = async (conn: SavedConnection) => {
 	      setBatchConnContext(conn);
 
@@ -9221,7 +9267,7 @@ const Sidebar: React.FC<{
                   <button
                       type="button"
                       className="gn-v2-rail-tool gn-v2-rail-action"
-                      onClick={() => openBatchOperationModal()}
+                      onClick={() => openBatchTableExportWorkbench()}
                       aria-label={v2BatchTablesLabel}
                       data-sidebar-batch-table-action="true"
                   >
@@ -9232,7 +9278,7 @@ const Sidebar: React.FC<{
                   <button
                       type="button"
                       className="gn-v2-rail-tool gn-v2-rail-action"
-                      onClick={() => openBatchDatabaseModal()}
+                      onClick={() => openBatchDatabaseExportWorkbench()}
                       aria-label={v2BatchDatabasesLabel}
                       data-sidebar-batch-database-action="true"
                   >
@@ -9507,7 +9553,7 @@ const Sidebar: React.FC<{
                         icon={<TableOutlined />}
                         aria-label="批量操作表"
                         data-sidebar-batch-table-action="true"
-                        onClick={() => openBatchOperationModal()}
+                        onClick={() => openBatchTableExportWorkbench()}
                         style={{ color: legacyToolbarButtonColor }}
                     />
                 </Tooltip>
@@ -9520,7 +9566,7 @@ const Sidebar: React.FC<{
                         icon={<DatabaseOutlined />}
                         aria-label="批量操作库"
                         data-sidebar-batch-database-action="true"
-                        onClick={() => openBatchDatabaseModal()}
+                        onClick={() => openBatchDatabaseExportWorkbench()}
                         style={{ color: legacyToolbarButtonColor }}
                     />
                 </Tooltip>
diff --git a/frontend/src/components/TableExportWorkbench.test.tsx b/frontend/src/components/TableExportWorkbench.test.tsx
index 6222e75..5c240a9 100644
--- a/frontend/src/components/TableExportWorkbench.test.tsx
+++ b/frontend/src/components/TableExportWorkbench.test.tsx
@@ -4,6 +4,7 @@ import { renderToStaticMarkup } from 'react-dom/server';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import TableExportWorkbench, { buildTableExportHistoryEntry } from './TableExportWorkbench';
+import type { ExportProgressState } from './useExportProgressRunner';
 
 const mockUpsertTableExportHistory = vi.fn();
 const createMockStoreState = () => ({
@@ -24,7 +25,7 @@ const createMockStoreState = () => ({
   tableExportHistories: {},
   upsertTableExportHistory: mockUpsertTableExportHistory,
 });
-const createMockProgressRunnerState = () => ({
+const createMockProgressRunnerState = (): ExportProgressState => ({
   open: true,
   jobId: 'job-1',
   title: '导出 SYS.test',
@@ -40,17 +41,27 @@ const createMockProgressRunnerState = () => ({
   filePath: '/Users/yangguofeng/Desktop/SYS.test.xlsx',
   message: '',
 });
+const createProgressRunnerState = (
+  overrides: Partial<ExportProgressState> = {},
+): ExportProgressState => ({
+  ...createMockProgressRunnerState(),
+  ...overrides,
+});
 
 let mockStoreState = createMockStoreState();
-let mockProgressRunnerState = createMockProgressRunnerState();
+let mockProgressRunnerState: ExportProgressState = createMockProgressRunnerState();
 
 vi.mock('../store', () => ({
   useStore: (selector: (state: any) => any) => selector(mockStoreState),
 }));
 
 vi.mock('../../wailsjs/go/app/App', () => ({
+  DBGetDatabases: vi.fn(),
+  DBGetTables: vi.fn(),
+  ExportDatabasesSQLWithOptions: vi.fn(),
   ExportQueryWithOptions: vi.fn(),
   ExportTableWithOptions: vi.fn(),
+  ExportTablesSQLWithOptions: vi.fn(),
 }));
 
 vi.mock('./useExportProgressRunner', () => ({
@@ -167,6 +178,99 @@ describe('TableExportWorkbench', () => {
     expect(markup).toContain('/Users/yangguofeng/Desktop/SYS.test.xlsx');
   });
 
+  it('renders batch table workbench copy and object progress summary', () => {
+    mockProgressRunnerState = createProgressRunnerState({
+      title: '结构 · SYS',
+      targetName: 'SYS · 8 个对象',
+      format: 'SQL',
+      current: 3,
+      total: 8,
+      totalRowsKnown: true,
+      filePath: '/Users/yangguofeng/Desktop/SYS_schema_8tables.sql',
+      stage: '正在导出 orders (4/8)',
+    });
+
+    const markup = renderToStaticMarkup(
+      <TableExportWorkbench
+        tab={{
+          id: 'table-export-batch-tables-conn-1-SYS',
+          title: '批量导出对象',
+          type: 'table-export',
+          connectionId: 'conn-1',
+          dbName: 'SYS',
+          exportWorkbenchMode: 'batch-tables',
+        }}
+      />,
+    );
+
+    expect(markup).toContain('模式 · 批量对象');
+    expect(markup).toContain('导出内容');
+    expect(markup).toContain('批量对象导出会统一生成一个 SQL 文件');
+    expect(markup).toContain('已完成 3 / 8 个对象');
+    expect(markup).toContain('/Users/yangguofeng/Desktop/SYS_schema_8tables.sql');
+  });
+
+  it('renders batch database history with directory-oriented labels', () => {
+    mockProgressRunnerState = createProgressRunnerState({
+      open: false,
+      jobId: '',
+      title: '',
+      targetName: '',
+      format: '',
+      startedAt: 0,
+      finishedAt: 0,
+      status: 'idle',
+      stage: '',
+      current: 0,
+      total: 0,
+      totalRowsKnown: false,
+      filePath: '',
+      message: '',
+    });
+    mockStoreState = {
+      ...createMockStoreState(),
+      tableExportHistories: {
+        'conn-1::__batch_databases__': [
+          {
+            jobId: 'job-batch-db-1',
+            targetName: '3 个数据库',
+            startedAt: 1_000,
+            finishedAt: 31_000,
+            format: 'SQL',
+            scope: 'selectedDatabases',
+            scopeLabel: '已选数据库（3）',
+            strategyLabel: '批量库 SQL 导出 · 导出库结构',
+            status: 'done',
+            stage: '导出完成',
+            current: 3,
+            total: 3,
+            totalRowsKnown: true,
+            filePath: '/Users/yangguofeng/Desktop/export-batch-dbs',
+            message: '',
+          },
+        ],
+      },
+    };
+
+    const markup = renderToStaticMarkup(
+      <TableExportWorkbench
+        tab={{
+          id: 'table-export-batch-databases-conn-1',
+          title: '批量导出库',
+          type: 'table-export',
+          connectionId: 'conn-1',
+          exportWorkbenchMode: 'batch-databases',
+        }}
+      />,
+    );
+
+    expect(markup).toContain('模式 · 批量库');
+    expect(markup).toContain('将在开始导出时先选择输出目录');
+    expect(markup).toContain('已完成 3 / 3 个库');
+    expect(markup).toContain('/Users/yangguofeng/Desktop/export-batch-dbs');
+    expect(markup).toContain('目录');
+  });
+
   it('keeps only one progress component in source and no longer uses top tabs', () => {
     const source = readFileSync(new URL('./TableExportWorkbench.tsx', import.meta.url), 'utf8');
     const progressMatches = source.match(/<ExportProgressBar\b/g) || [];
diff --git a/frontend/src/components/TableExportWorkbench.tsx b/frontend/src/components/TableExportWorkbench.tsx
index 0c57edd..a6a2e37 100644
--- a/frontend/src/components/TableExportWorkbench.tsx
+++ b/frontend/src/components/TableExportWorkbench.tsx
@@ -1,7 +1,14 @@
 import React, { useEffect, useMemo, useState } from 'react';
-import { Alert, Button, Empty, InputNumber, Select, Typography } from 'antd';
+import { Alert, Button, Empty, InputNumber, Select, Tooltip, Typography } from 'antd';
 import { ClockCircleOutlined, ExportOutlined, ReloadOutlined } from '@ant-design/icons';
-import { ExportQueryWithOptions, ExportTableWithOptions } from '../../wailsjs/go/app/App';
+import {
+  DBGetDatabases,
+  DBGetTables,
+  ExportDatabasesSQLWithOptions,
+  ExportQueryWithOptions,
+  ExportTableWithOptions,
+  ExportTablesSQLWithOptions,
+} from '../../wailsjs/go/app/App';
 import { useStore } from '../store';
 import type {
   SavedConnection,
@@ -12,7 +19,7 @@ import type {
 } from '../types';
 import { buildRpcConnectionConfig } from '../utils/connectionRpcConfig';
 import { resolveConnectionHostSummary } from '../utils/tabDisplay';
-import { buildTableExportHistoryKey } from '../utils/tableExportTab';
+import { buildExportWorkbenchHistoryKey } from '../utils/tableExportTab';
 import {
   formatExportElapsed,
   formatExportProgressRows,
@@ -33,10 +40,35 @@ import type { ExportProgressState } from './useExportProgressRunner';
 const { Text, Paragraph, Title } = Typography;
 const EMPTY_HISTORY: TableExportHistoryEntry[] = [];
 
+type ExportWorkbenchMode = NonNullable<TabData['exportWorkbenchMode']>;
+type BatchTableExportMode = 'schema' | 'dataOnly' | 'backup';
+type BatchDatabaseExportMode = 'schema' | 'backup';
+type SelectOption = { value: string; label: React.ReactNode; title: string };
+
 const DEFAULT_SCOPE_OPTIONS: TableExportScopeOption[] = [
   { value: 'all', label: '全表数据', description: '后台重新查询整张表并导出全部数据。' },
 ];
 
+const SELECT_ELLIPSIS_LABEL_STYLE: React.CSSProperties = {
+  display: 'block',
+  width: '100%',
+  minWidth: 0,
+  overflow: 'hidden',
+  textOverflow: 'ellipsis',
+  whiteSpace: 'nowrap',
+};
+
+const BATCH_TABLE_EXPORT_MODE_OPTIONS: Array<{ value: BatchTableExportMode; label: string; description: string }> = [
+  { value: 'schema', label: '结构', description: '导出当前数据库下所选对象的建表或定义 SQL。' },
+  { value: 'dataOnly', label: '仅数据', description: '导出所选对象的数据 INSERT 语句。' },
+  { value: 'backup', label: '备份', description: '导出所选对象的结构和数据 SQL。' },
+];
+
+const BATCH_DATABASE_EXPORT_MODE_OPTIONS: Array<{ value: BatchDatabaseExportMode; label: string; description: string }> = [
+  { value: 'schema', label: '导出库结构', description: '按数据库分别生成结构 SQL 文件。' },
+  { value: 'backup', label: '备份库', description: '按数据库分别生成结构加数据 SQL 文件。' },
+];
+
 const normalizeScopeOptions = (input: TabData['tableExportScopeOptions']): TableExportScopeOption[] => {
   if (!Array.isArray(input) || input.length === 0) {
     return DEFAULT_SCOPE_OPTIONS;
@@ -68,6 +100,8 @@ const formatDateTime = (timestamp: number): string => {
   return new Date(timestamp).toLocaleString('zh-CN', { hour12: false });
 };
 
+const resolveWorkbenchMode = (tab: TabData): ExportWorkbenchMode => tab.exportWorkbenchMode || 'single';
+
 const resolveObjectTypeLabel = (objectType?: TabData['objectType']): string => {
   if (objectType === 'view') return '视图';
   if (objectType === 'materialized-view') return '物化视图';
@@ -106,6 +140,67 @@ const renderStatusPill = (status: ExportProgressStatus) => {
   );
 };
 
+const renderSelectLabel = (text: string): React.ReactNode => (
+  <span title={text} style={SELECT_ELLIPSIS_LABEL_STYLE}>
+    {text}
+  </span>
+);
+
+const toSortedSelectOptions = (values: string[]): SelectOption[] =>
+  values
+    .filter((value) => String(value || '').trim())
+    .map((value) => ({
+      value: String(value).trim(),
+      label: renderSelectLabel(String(value).trim()),
+      title: String(value).trim(),
+    }))
+    .sort((a, b) => a.title.toLowerCase().localeCompare(b.title.toLowerCase()));
+
+const filterOptionByLabel = (input: string, option?: { title?: string; value?: string }) =>
+  String(option?.title || option?.value || '').toLowerCase().includes(String(input || '').trim().toLowerCase());
+
+const resolveBatchTableModeMeta = (mode: BatchTableExportMode) =>
+  BATCH_TABLE_EXPORT_MODE_OPTIONS.find((item) => item.value === mode) || BATCH_TABLE_EXPORT_MODE_OPTIONS[0];
+
+const resolveBatchDatabaseModeMeta = (mode: BatchDatabaseExportMode) =>
+  BATCH_DATABASE_EXPORT_MODE_OPTIONS.find((item) => item.value === mode) || BATCH_DATABASE_EXPORT_MODE_OPTIONS[0];
+
+const resolveBatchTablesTargetName = (dbName: string, objectCount: number): string => {
+  const safeDbName = String(dbName || '').trim() || '当前数据库';
+  return `${safeDbName} · ${objectCount} 个对象`;
+};
+
+const resolveBatchDatabasesTargetName = (databaseCount: number): string => `${databaseCount} 个数据库`;
+
+const formatWorkbenchProgressSummary = (
+  mode: ExportWorkbenchMode,
+  current: number,
+  total: number,
+  totalRowsKnown: boolean,
+): string => {
+  if (mode === 'batch-tables') {
+    if (!totalRowsKnown) return '批量对象导出正在执行';
+    return `已完成 ${Math.min(current, total).toLocaleString()} / ${total.toLocaleString()} 个对象`;
+  }
+  if (mode === 'batch-databases') {
+    if (!totalRowsKnown) return '批量库导出正在执行';
+    return `已完成 ${Math.min(current, total).toLocaleString()} / ${total.toLocaleString()} 个库`;
+  }
+  return formatExportProgressRows(current, total, totalRowsKnown);
+};
+
+const resolveProgressHint = (mode: ExportWorkbenchMode, status: ExportProgressStatus, totalRowsKnown: boolean): string | null => {
+  if (totalRowsKnown || status === 'done' || status === 'error') {
+    return null;
+  }
+  if (mode === 'single') {
+    return '当前未预先统计总行数，暂不显示百分比，写入行数为实时值。';
+  }
+  return '当前阶段为后端执行中的过程提示，整体进度会在对象或数据库完成后推进。';
+};
+
+const resolveOutputLabel = (mode: ExportWorkbenchMode): string => (mode === 'batch-databases' ? '输出目录' : '输出文件');
+
 export const buildTableExportHistoryEntry = ({
   progressState,
   existingEntry,
@@ -119,7 +214,7 @@ export const buildTableExportHistoryEntry = ({
   existingEntry?: TableExportHistoryEntry;
   fallbackTargetName: string;
   fallbackFormat: string;
-  scope: TableExportScope;
+  scope: string;
   scopeLabel: string;
   strategyLabel: string;
 }): TableExportHistoryEntry => ({
@@ -143,12 +238,54 @@ export const buildTableExportHistoryEntry = ({
 const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
   const connections = useStore((state) => state.connections);
   const theme = useStore((state) => state.theme);
+  const upsertTableExportHistory = useStore((state) => state.upsertTableExportHistory);
+  const workbenchMode = resolveWorkbenchMode(tab);
+  const isSingleWorkbench = workbenchMode === 'single';
+  const isBatchTablesWorkbench = workbenchMode === 'batch-tables';
+  const isBatchDatabasesWorkbench = workbenchMode === 'batch-databases';
+
+  const [selectedConnectionId, setSelectedConnectionId] = useState(() => String(tab.connectionId || '').trim());
+  const [selectedDbName, setSelectedDbName] = useState(() => String(tab.dbName || '').trim());
+  const [availableDatabases, setAvailableDatabases] = useState<SelectOption[]>([]);
+  const [availableObjects, setAvailableObjects] = useState<SelectOption[]>([]);
+  const [selectedObjectNames, setSelectedObjectNames] = useState<string[]>([]);
+  const [selectedDatabaseNames, setSelectedDatabaseNames] = useState<string[]>([]);
+  const [batchTableMode, setBatchTableMode] = useState<BatchTableExportMode>('schema');
+  const [batchDatabaseMode, setBatchDatabaseMode] = useState<BatchDatabaseExportMode>('schema');
+  const [loadingDatabases, setLoadingDatabases] = useState(false);
+  const [loadingObjects, setLoadingObjects] = useState(false);
+  const [databaseLoadError, setDatabaseLoadError] = useState('');
+  const [objectLoadError, setObjectLoadError] = useState('');
+
+  const effectiveConnectionId = isSingleWorkbench ? String(tab.connectionId || '').trim() : selectedConnectionId;
+  const effectiveDbName = isSingleWorkbench ? String(tab.dbName || '').trim() : selectedDbName;
+  const connection = useMemo(
+    () => connections.find((item) => item.id === effectiveConnectionId),
+    [connections, effectiveConnectionId],
+  );
+  const connectionOptions = useMemo(
+    () =>
+      connections.map((item) => ({
+        value: item.id,
+        label: renderSelectLabel(item.name),
+        title: item.name,
+      })),
+    [connections],
+  );
+  const connectionConfig = useMemo(
+    () => (connection ? normalizeConnectionConfig(connection) : null),
+    [connection],
+  );
   const exportHistoryKey = useMemo(
-    () => buildTableExportHistoryKey(tab.connectionId, tab.dbName, tab.tableName),
-    [tab.connectionId, tab.dbName, tab.tableName],
+    () => buildExportWorkbenchHistoryKey({
+      connectionId: effectiveConnectionId,
+      dbName: isBatchDatabasesWorkbench ? undefined : effectiveDbName,
+      tableName: isSingleWorkbench ? tab.tableName : undefined,
+      exportWorkbenchMode: workbenchMode,
+    }),
+    [effectiveConnectionId, effectiveDbName, isBatchDatabasesWorkbench, isSingleWorkbench, tab.tableName, workbenchMode],
   );
   const history = useStore((state) => state.tableExportHistories[exportHistoryKey] || EMPTY_HISTORY);
-  const upsertTableExportHistory = useStore((state) => state.upsertTableExportHistory);
   const darkMode = theme === 'dark';
   const shellBg = darkMode ? '#101319' : '#f5f7fb';
   const panelBg = darkMode ? '#161b22' : '#ffffff';
@@ -159,14 +296,6 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
   const subtleBg = darkMode ? 'rgba(255,255,255,0.04)' : '#f8fafc';
   const pillBg = darkMode ? 'rgba(255,255,255,0.06)' : '#eef2f7';
 
-  const connection = useMemo(
-    () => connections.find((item) => item.id === tab.connectionId),
-    [connections, tab.connectionId],
-  );
-  const connectionConfig = useMemo(
-    () => (connection ? normalizeConnectionConfig(connection) : null),
-    [connection],
-  );
   const scopeOptions = useMemo(
     () => normalizeScopeOptions(tab.tableExportScopeOptions),
     [tab.tableExportScopeOptions],
@@ -177,6 +306,13 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
   const [nowTick, setNowTick] = useState(() => Date.now());
   const { state: progressState, reset, runExportWithProgress, isRunning } = useExportProgressRunner();
 
+  useEffect(() => {
+    if (isSingleWorkbench || selectedConnectionId || connections.length === 0) {
+      return;
+    }
+    setSelectedConnectionId(connections[0].id);
+  }, [connections, isSingleWorkbench, selectedConnectionId]);
+
   useEffect(() => {
     setScope((prev) => {
       if (scopeOptions.some((item) => item.value === prev && !item.disabled)) {
@@ -196,6 +332,114 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
     };
   }, [progressState.startedAt, progressState.finishedAt, isRunning]);
 
+  useEffect(() => {
+    if (isSingleWorkbench || !connectionConfig) {
+      if (!isSingleWorkbench) {
+        setAvailableDatabases([]);
+        setAvailableObjects([]);
+        setSelectedObjectNames([]);
+        setSelectedDatabaseNames([]);
+        setDatabaseLoadError('');
+        setObjectLoadError('');
+      }
+      return;
+    }
+    let alive = true;
+    setLoadingDatabases(true);
+    setDatabaseLoadError('');
+    DBGetDatabases(buildRpcConnectionConfig(connectionConfig) as any)
+      .then((res) => {
+        if (!alive) return;
+        if (!res.success) {
+          setAvailableDatabases([]);
+          setSelectedDatabaseNames([]);
+          setDatabaseLoadError(res.message || '获取数据库列表失败');
+          return;
+        }
+        const dbRows: any[] = Array.isArray(res.data) ? res.data : [];
+        let nextOptions = dbRows
+          .map((row) => String(row.Database || row.database || '').trim())
+          .filter(Boolean);
+        if (connection?.includeDatabases && connection.includeDatabases.length > 0) {
+          nextOptions = nextOptions.filter((name) => connection.includeDatabases!.includes(name));
+        }
+        const normalizedOptions = toSortedSelectOptions(nextOptions);
+        setAvailableDatabases(normalizedOptions);
+        if (isBatchTablesWorkbench) {
+          const hasCurrentDb = normalizedOptions.some((item) => item.value === selectedDbName);
+          if (!hasCurrentDb) {
+            setSelectedDbName('');
+            setAvailableObjects([]);
+            setSelectedObjectNames([]);
+          }
+        } else {
+          const availableNameSet = new Set(normalizedOptions.map((item) => item.value));
+          setSelectedDatabaseNames((prev) => prev.filter((name) => availableNameSet.has(name)));
+        }
+      })
+      .catch((error: any) => {
+        if (!alive) return;
+        setAvailableDatabases([]);
+        setSelectedDatabaseNames([]);
+        setDatabaseLoadError(error?.message || '获取数据库列表失败');
+      })
+      .finally(() => {
+        if (alive) {
+          setLoadingDatabases(false);
+        }
+      });
+    return () => {
+      alive = false;
+    };
+  }, [connection?.includeDatabases, connectionConfig, isBatchTablesWorkbench, isSingleWorkbench, selectedDbName]);
+
+  useEffect(() => {
+    if (!isBatchTablesWorkbench || !connectionConfig || !selectedDbName) {
+      if (isBatchTablesWorkbench) {
+        setAvailableObjects([]);
+        setSelectedObjectNames([]);
+        setObjectLoadError('');
+      }
+      return;
+    }
+    let alive = true;
+    setLoadingObjects(true);
+    setObjectLoadError('');
+    DBGetTables(buildRpcConnectionConfig(connectionConfig) as any, selectedDbName)
+      .then((res) => {
+        if (!alive) return;
+        if (!res.success) {
+          setAvailableObjects([]);
+          setSelectedObjectNames([]);
+          setObjectLoadError(res.message || '获取对象列表失败');
+          return;
+        }
+        const tableRows: any[] = Array.isArray(res.data) ? res.data : [];
+        const nextOptions = toSortedSelectOptions(
+          tableRows
+            .map((row) => String(Object.values(row)[0] || '').trim())
+            .filter(Boolean),
+        );
+        setAvailableObjects(nextOptions);
+        const availableNameSet = new Set(nextOptions.map((item) => item.value));
+        setSelectedObjectNames((prev) => prev.filter((name) => availableNameSet.has(name)));
+      })
+      .catch((error: any) => {
+        if (!alive) return;
+        setAvailableObjects([]);
+        setSelectedObjectNames([]);
+        setObjectLoadError(error?.message || '获取对象列表失败');
+      })
+      .finally(() => {
+        if (alive) {
+          setLoadingObjects(false);
+        }
+      });
+    return () => {
+      alive = false;
+    };
+  }, [connectionConfig, isBatchTablesWorkbench, selectedDbName]);
+
   const hostSummary = useMemo(
     () => resolveConnectionHostSummary(connection?.config),
     [connection?.config],
@@ -204,17 +448,41 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
     () => scopeOptions.find((item) => item.value === scope),
     [scope, scopeOptions],
   );
-  const activeScopeLabel = activeScopeOption?.label || scope;
   const activeScopeQuery = useMemo(
     () => String(tab.tableExportQueryByScope?.[scope] || '').trim(),
     [scope, tab.tableExportQueryByScope],
   );
-  const activeScopeRowCount = useMemo(() => {
+  const singleScopeRowCount = useMemo(() => {
     const raw = tab.tableExportRowCountByScope?.[scope];
     return Number.isFinite(Number(raw)) && Number(raw) >= 0 ? Number(raw) : undefined;
   }, [scope, tab.tableExportRowCountByScope]);
-  const totalRowsKnown = typeof activeScopeRowCount === 'number';
-  const exportStrategyLabel = scope === 'all' && !activeScopeQuery ? '整表导出链路' : 'SQL 重放导出';
+  const singleTotalRowsKnown = typeof singleScopeRowCount === 'number';
+  const singleScopeLabel = activeScopeOption?.label || scope;
+  const batchTableModeMeta = resolveBatchTableModeMeta(batchTableMode);
+  const batchDatabaseModeMeta = resolveBatchDatabaseModeMeta(batchDatabaseMode);
+  const activeScopeLabel = isSingleWorkbench
+    ? singleScopeLabel
+    : isBatchTablesWorkbench
+      ? `已选对象（${selectedObjectNames.length}）`
+      : `已选数据库（${selectedDatabaseNames.length}）`;
+  const activeScopeCount = isSingleWorkbench
+    ? singleScopeRowCount
+    : (isBatchTablesWorkbench ? selectedObjectNames.length : selectedDatabaseNames.length);
+  const totalRowsKnown = isSingleWorkbench ? singleTotalRowsKnown : true;
+  const exportStrategyLabel = isSingleWorkbench
+    ? (scope === 'all' && !activeScopeQuery ? '整表导出链路' : 'SQL 重放导出')
+    : (isBatchTablesWorkbench ? `批量对象 SQL 导出 · ${batchTableModeMeta.label}` : `批量库 SQL 导出 · ${batchDatabaseModeMeta.label}`);
+  const currentElapsedMs = useMemo(
+    () => resolveExportElapsedMs(progressState.startedAt, progressState.finishedAt, nowTick),
+    [nowTick, progressState.finishedAt, progressState.startedAt],
+  );
+
+  const currentProgressHint = resolveProgressHint(workbenchMode, progressState.status, progressState.totalRowsKnown);
+  const progressOutputLabel = resolveOutputLabel(workbenchMode);
+  const fallbackTargetName = isSingleWorkbench
+    ? (tab.tableName || '未命名对象')
+    : (isBatchTablesWorkbench ? resolveBatchTablesTargetName(selectedDbName, selectedObjectNames.length) : resolveBatchDatabasesTargetName(selectedDatabaseNames.length));
+  const fallbackFormat = isSingleWorkbench ? String(format || '').toUpperCase() : 'SQL';
 
   useEffect(() => {
     const jobId = String(progressState.jobId || '').trim();
@@ -223,9 +491,9 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
     const entry = buildTableExportHistoryEntry({
       progressState,
       existingEntry,
-      fallbackTargetName: tab.tableName || '未命名对象',
-      fallbackFormat: String(format || '').toUpperCase(),
-      scope,
+      fallbackTargetName,
+      fallbackFormat,
+      scope: isSingleWorkbench ? scope : (isBatchTablesWorkbench ? 'selectedObjects' : 'selectedDatabases'),
       scopeLabel: activeScopeLabel,
       strategyLabel: exportStrategyLabel,
     });
@@ -233,8 +501,13 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
   }, [
     activeScopeLabel,
     exportHistoryKey,
-    format,
+    exportStrategyLabel,
+    fallbackFormat,
+    fallbackTargetName,
     history,
+    isBatchDatabasesWorkbench,
+    isBatchTablesWorkbench,
+    isSingleWorkbench,
     progressState.current,
     progressState.filePath,
     progressState.finishedAt,
@@ -248,16 +521,9 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
     progressState.total,
     progressState.totalRowsKnown,
     scope,
-    tab.tableName,
-    exportStrategyLabel,
     upsertTableExportHistory,
   ]);
 
-  const canStart = !!connectionConfig && !!tab.tableName && !!scope && !activeScopeOption?.disabled && (scope === 'all' || !!activeScopeQuery);
-  const currentElapsedMs = useMemo(
-    () => resolveExportElapsedMs(progressState.startedAt, progressState.finishedAt, nowTick),
-    [nowTick, progressState.finishedAt, progressState.startedAt],
-  );
   const historyEntries = useMemo(
     () => history.filter((entry) => entry.jobId !== progressState.jobId),
     [history, progressState.jobId],
@@ -268,8 +534,39 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
   );
   const currentScopeLabel = currentHistoryEntry?.scopeLabel || activeScopeLabel;
   const currentStrategyLabel = currentHistoryEntry?.strategyLabel || exportStrategyLabel;
+  const currentProgressSummary = formatWorkbenchProgressSummary(
+    workbenchMode,
+    progressState.current,
+    progressState.total,
+    progressState.totalRowsKnown,
+  );
 
-  const handleStartExport = async () => {
+  const canStart = useMemo(() => {
+    if (!connectionConfig || isRunning) {
+      return false;
+    }
+    if (isSingleWorkbench) {
+      return !!tab.tableName && !!scope && !activeScopeOption?.disabled && (scope === 'all' || !!activeScopeQuery);
+    }
+    if (isBatchTablesWorkbench) {
+      return !!selectedDbName && selectedObjectNames.length > 0;
+    }
+    return selectedDatabaseNames.length > 0;
+  }, [
+    activeScopeOption?.disabled,
+    activeScopeQuery,
+    connectionConfig,
+    isBatchTablesWorkbench,
+    isRunning,
+    isSingleWorkbench,
+    scope,
+    selectedDatabaseNames.length,
+    selectedDbName,
+    selectedObjectNames.length,
+    tab.tableName,
+  ]);
+
+  const handleStartSingleExport = async () => {
     if (!connectionConfig) {
       return;
     }
@@ -281,14 +578,14 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
       title: tab.title || `导出 ${objectName}`,
       targetName: objectName,
       format,
-      totalRows: activeScopeRowCount,
+      totalRows: singleScopeRowCount,
       run: (jobId) => {
         const options = {
           format,
           xlsxMaxRowsPerSheet,
           jobId,
-          totalRowsHint: totalRowsKnown ? activeScopeRowCount : 0,
-          totalRowsKnown,
+          totalRowsHint: singleTotalRowsKnown ? singleScopeRowCount : 0,
+          totalRowsKnown: singleTotalRowsKnown,
         };
         if (scope !== 'all' && activeScopeQuery) {
           return ExportQueryWithOptions(
@@ -318,6 +615,108 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
     });
   };
 
+  const handleStartBatchTablesExport = async () => {
+    if (!connectionConfig || !selectedDbName || selectedObjectNames.length === 0) {
+      return;
+    }
+    const includeSchema = batchTableMode !== 'dataOnly';
+    const includeData = batchTableMode !== 'schema';
+    await runExportWithProgress({
+      title: `${batchTableModeMeta.label} · ${selectedDbName}`,
+      targetName: resolveBatchTablesTargetName(selectedDbName, selectedObjectNames.length),
+      format: 'sql',
+      totalRows: selectedObjectNames.length,
+      run: (jobId) =>
+        ExportTablesSQLWithOptions(
+          buildRpcConnectionConfig(connectionConfig) as any,
+          selectedDbName,
+          selectedObjectNames,
+          includeSchema,
+          includeData,
+          {
+            format: 'sql',
+            jobId,
+            totalRowsHint: selectedObjectNames.length,
+            totalRowsKnown: true,
+          } as any,
+        ),
+    });
+  };
+
+  const handleStartBatchDatabasesExport = async () => {
+    if (!connectionConfig || selectedDatabaseNames.length === 0) {
+      return;
+    }
+    const includeData = batchDatabaseMode === 'backup';
+    await runExportWithProgress({
+      title: batchDatabaseModeMeta.label,
+      targetName: resolveBatchDatabasesTargetName(selectedDatabaseNames.length),
+      format: 'sql',
+      totalRows: selectedDatabaseNames.length,
+      run: (jobId) =>
+        ExportDatabasesSQLWithOptions(
+          buildRpcConnectionConfig(connectionConfig) as any,
+          selectedDatabaseNames,
+          includeData,
+          {
+            format: 'sql',
+            jobId,
+            totalRowsHint: selectedDatabaseNames.length,
+            totalRowsKnown: true,
+          } as any,
+        ),
+    });
+  };
+
+  const handleStartExport = async () => {
+    if (isSingleWorkbench) {
+      await handleStartSingleExport();
+      return;
+    }
+    if (isBatchTablesWorkbench) {
+      await handleStartBatchTablesExport();
+      return;
+    }
+    await handleStartBatchDatabasesExport();
+  };
+
+  const headerBadges = useMemo(() => {
+    if (isSingleWorkbench) {
+      return [
+        `${resolveObjectTypeLabel(tab.objectType)} · ${tab.tableName || '-'}`,
+        `数据库 · ${tab.dbName || '-'}`,
+        `连接 · ${connection?.name || '-'}`,
+        `Host · ${hostSummary || '-'}`,
+      ];
+    }
+    if (isBatchTablesWorkbench) {
+      return [
+        '模式 · 批量对象',
+        `数据库 · ${selectedDbName || '-'}`,
+        `连接 · ${connection?.name || '-'}`,
+        `对象数 · ${selectedObjectNames.length}`,
+        `Host · ${hostSummary || '-'}`,
+      ];
+    }
+    return [
+      '模式 · 批量库',
+      `连接 · ${connection?.name || '-'}`,
+      `已选库 · ${selectedDatabaseNames.length}`,
+      `Host · ${hostSummary || '-'}`,
+    ];
+  }, [
+    connection?.name,
+    hostSummary,
+    isBatchTablesWorkbench,
+    isSingleWorkbench,
+    selectedDatabaseNames.length,
+    selectedDbName,
+    selectedObjectNames.length,
+    tab.dbName,
+    tab.objectType,
+    tab.tableName,
+  ]);
+
   return (
     <div
       data-export-workbench="true"
@@ -342,12 +741,7 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
           </div>
         </div>
         <div style={{ display: 'flex', gap: 8, flexWrap: 'wrap' }}>
-          {[
-            `${resolveObjectTypeLabel(tab.objectType)} · ${tab.tableName || '-'}`,
-            `数据库 · ${tab.dbName || '-'}`,
-            `连接 · ${connection?.name || '-'}`,
-            `Host · ${hostSummary || '-'}`,
-          ].map((label) => (
+          {headerBadges.map((label) => (
             <span
               key={label}
               style={{
@@ -396,22 +790,55 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
         >
           <div>
             <div style={{ fontSize: 13, fontWeight: 600, color: headingColor, marginBottom: 10 }}>导出配置</div>
-            <div style={{ display: 'grid', gridTemplateColumns: '84px minmax(0, 1fr)', rowGap: 10, columnGap: 12 }}>
-              <Text type="secondary">对象</Text>
-              <Text>{tab.tableName || '-'}</Text>
+            {isSingleWorkbench ? (
+              <div style={{ display: 'grid', gridTemplateColumns: '84px minmax(0, 1fr)', rowGap: 10, columnGap: 12 }}>
+                <Text type="secondary">对象</Text>
+                <Text>{tab.tableName || '-'}</Text>
 
-              <Text type="secondary">类型</Text>
-              <Text>{resolveObjectTypeLabel(tab.objectType)}</Text>
+                <Text type="secondary">类型</Text>
+                <Text>{resolveObjectTypeLabel(tab.objectType)}</Text>
 
-              <Text type="secondary">连接</Text>
-              <Text>{connection?.name || '-'}</Text>
+                <Text type="secondary">连接</Text>
+                <Text>{connection?.name || '-'}</Text>
 
-              <Text type="secondary">数据库</Text>
-              <Text>{tab.dbName || '-'}</Text>
+                <Text type="secondary">数据库</Text>
+                <Text>{tab.dbName || '-'}</Text>
 
-              <Text type="secondary">Host</Text>
-              <Text>{hostSummary || '-'}</Text>
-            </div>
+                <Text type="secondary">Host</Text>
+                <Text>{hostSummary || '-'}</Text>
+              </div>
+            ) : isBatchTablesWorkbench ? (
+              <div style={{ display: 'grid', gridTemplateColumns: '84px minmax(0, 1fr)', rowGap: 10, columnGap: 12 }}>
+                <Text type="secondary">模式</Text>
+                <Text>批量对象</Text>
+
+                <Text type="secondary">连接</Text>
+                <Text>{connection?.name || '-'}</Text>
+
+                <Text type="secondary">数据库</Text>
+                <Text>{selectedDbName || '-'}</Text>
+
+                <Text type="secondary">对象数</Text>
+                <Text>{selectedObjectNames.length}</Text>
+
+                <Text type="secondary">Host</Text>
+                <Text>{hostSummary || '-'}</Text>
+              </div>
+            ) : (
+              <div style={{ display: 'grid', gridTemplateColumns: '84px minmax(0, 1fr)', rowGap: 10, columnGap: 12 }}>
+                <Text type="secondary">模式</Text>
+                <Text>批量库</Text>
+
+                <Text type="secondary">连接</Text>
+                <Text>{connection?.name || '-'}</Text>
+
+                <Text type="secondary">已选库</Text>
+                <Text>{selectedDatabaseNames.length}</Text>
+
+                <Text type="secondary">Host</Text>
+                <Text>{hostSummary || '-'}</Text>
+              </div>
+            )}
           </div>
 
           {!connectionConfig ? (
@@ -423,60 +850,284 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
             />
           ) : null}
 
+          {databaseLoadError ? (
+            <Alert
+              type="error"
+              showIcon
+              message="数据库列表加载失败"
+              description={databaseLoadError}
+            />
+          ) : null}
+
+          {objectLoadError ? (
+            <Alert
+              type="error"
+              showIcon
+              message="对象列表加载失败"
+              description={objectLoadError}
+            />
+          ) : null}
+
           <div style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
-            <div>
-              <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>导出范围</div>
-              <Select
-                value={scope}
-                options={scopeOptions.map((item) => ({
-                  value: item.value,
-                  label: item.label,
-                  disabled: item.disabled,
-                }))}
-                onChange={(next) => setScope(next as TableExportScope)}
-              />
-              {activeScopeOption?.description ? (
-                <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
-                  {activeScopeOption.description}
+            {isSingleWorkbench ? (
+              <>
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>导出范围</div>
+                  <Select
+                    style={{ width: '100%' }}
+                    value={scope}
+                    options={scopeOptions.map((item) => ({
+                      value: item.value,
+                      label: item.label,
+                      disabled: item.disabled,
+                    }))}
+                    onChange={(next) => setScope(next as TableExportScope)}
+                  />
+                  {activeScopeOption?.description ? (
+                    <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
+                      {activeScopeOption.description}
+                    </div>
+                  ) : null}
                 </div>
-              ) : null}
-            </div>
 
-            <div>
-              <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>导出格式</div>
-              <Select
-                value={format}
-                options={DATA_EXPORT_FORMAT_OPTIONS}
-                onChange={(next) => setFormat(next as DataExportFormat)}
-              />
-            </div>
-
-            {format === 'xlsx' ? (
-              <div>
-                <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>每个工作表最大行数</div>
-                <InputNumber
-                  min={1}
-                  max={MAX_XLSX_ROWS_PER_SHEET}
-                  step={100000}
-                  value={xlsxMaxRowsPerSheet}
-                  style={{ width: '100%' }}
-                  onChange={(value) => {
-                    const next = Number(value);
-                    setXlsxMaxRowsPerSheet(
-                      Number.isFinite(next) && next > 0
-                        ? Math.min(MAX_XLSX_ROWS_PER_SHEET, Math.trunc(next))
-                        : DEFAULT_XLSX_ROWS_PER_SHEET,
-                    );
-                  }}
-                />
-                <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
-                  仅 XLSX 生效，最大 {MAX_XLSX_ROWS_PER_SHEET.toLocaleString()} 行（不含表头）
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>导出格式</div>
+                  <Select
+                    style={{ width: '100%' }}
+                    value={format}
+                    options={DATA_EXPORT_FORMAT_OPTIONS}
+                    onChange={(next) => setFormat(next as DataExportFormat)}
+                  />
                 </div>
-              </div>
-            ) : null}
+
+                {format === 'xlsx' ? (
+                  <div>
+                    <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>每个工作表最大行数</div>
+                    <InputNumber
+                      min={1}
+                      max={MAX_XLSX_ROWS_PER_SHEET}
+                      step={100000}
+                      value={xlsxMaxRowsPerSheet}
+                      style={{ width: '100%' }}
+                      onChange={(value) => {
+                        const next = Number(value);
+                        setXlsxMaxRowsPerSheet(
+                          Number.isFinite(next) && next > 0
+                            ? Math.min(MAX_XLSX_ROWS_PER_SHEET, Math.trunc(next))
+                            : DEFAULT_XLSX_ROWS_PER_SHEET,
+                        );
+                      }}
+                    />
+                    <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
+                      仅 XLSX 生效，最大 {MAX_XLSX_ROWS_PER_SHEET.toLocaleString()} 行（不含表头）
+                    </div>
+                  </div>
+                ) : null}
+              </>
+            ) : isBatchTablesWorkbench ? (
+              <>
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>连接</div>
+                  <Tooltip title={connection?.name || undefined}>
+                    <div>
+                      <Select
+                        style={{ width: '100%' }}
+                        value={selectedConnectionId || undefined}
+                        placeholder="选择连接"
+                        options={connectionOptions}
+                        showSearch
+                        optionFilterProp="title"
+                        filterOption={filterOptionByLabel as any}
+                        onChange={(next) => {
+                          setSelectedConnectionId(String(next || '').trim());
+                          setSelectedDbName('');
+                          setSelectedObjectNames([]);
+                          setAvailableObjects([]);
+                          setObjectLoadError('');
+                        }}
+                      />
+                    </div>
+                  </Tooltip>
+                </div>
+
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>数据库</div>
+                  <Tooltip title={selectedDbName || undefined}>
+                    <div>
+                      <Select
+                        style={{ width: '100%' }}
+                        value={selectedDbName || undefined}
+                        placeholder={loadingDatabases ? '正在加载数据库...' : '选择数据库'}
+                        loading={loadingDatabases}
+                        options={availableDatabases}
+                        showSearch
+                        optionFilterProp="title"
+                        filterOption={filterOptionByLabel as any}
+                        onChange={(next) => {
+                          setSelectedDbName(String(next || '').trim());
+                          setSelectedObjectNames([]);
+                          setObjectLoadError('');
+                        }}
+                      />
+                    </div>
+                  </Tooltip>
+                </div>
+
+                <div>
+                  <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12, marginBottom: 6 }}>
+                    <div style={{ fontSize: 12, color: secondaryTextColor }}>对象</div>
+                    <div style={{ display: 'flex', gap: 8 }}>
+                      <Button
+                        size="small"
+                        type="text"
+                        disabled={availableObjects.length === 0}
+                        onClick={() => setSelectedObjectNames(availableObjects.map((item) => item.value))}
+                      >
+                        全选
+                      </Button>
+                      <Button
+                        size="small"
+                        type="text"
+                        disabled={selectedObjectNames.length === 0}
+                        onClick={() => setSelectedObjectNames([])}
+                      >
+                        清空
+                      </Button>
+                    </div>
+                  </div>
+                  <Select
+                    style={{ width: '100%' }}
+                    mode="multiple"
+                    value={selectedObjectNames}
+                    placeholder={selectedDbName ? (loadingObjects ? '正在加载对象...' : '选择对象') : '请先选择数据库'}
+                    loading={loadingObjects}
+                    options={availableObjects}
+                    disabled={!selectedDbName}
+                    showSearch
+                    optionFilterProp="title"
+                    filterOption={filterOptionByLabel as any}
+                    maxTagCount="responsive"
+                    onChange={(next) => setSelectedObjectNames((next as string[]).map((item) => String(item).trim()).filter(Boolean))}
+                  />
+                  <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
+                    当前库可选 {availableObjects.length} 个对象，已选 {selectedObjectNames.length} 个。
+                  </div>
+                </div>
+
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>导出内容</div>
+                  <Select
+                    style={{ width: '100%' }}
+                    value={batchTableMode}
+                    options={BATCH_TABLE_EXPORT_MODE_OPTIONS.map((item) => ({ value: item.value, label: item.label }))}
+                    onChange={(next) => setBatchTableMode(next as BatchTableExportMode)}
+                  />
+                  <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
+                    {batchTableModeMeta.description}
+                  </div>
+                </div>
+
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>导出格式</div>
+                  <Select
+                    style={{ width: '100%' }}
+                    value="sql"
+                    disabled
+                    options={[{ value: 'sql', label: 'SQL 文件' }]}
+                  />
+                </div>
+              </>
+            ) : (
+              <>
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>连接</div>
+                  <Tooltip title={connection?.name || undefined}>
+                    <div>
+                      <Select
+                        style={{ width: '100%' }}
+                        value={selectedConnectionId || undefined}
+                        placeholder="选择连接"
+                        options={connectionOptions}
+                        showSearch
+                        optionFilterProp="title"
+                        filterOption={filterOptionByLabel as any}
+                        onChange={(next) => {
+                          setSelectedConnectionId(String(next || '').trim());
+                          setSelectedDatabaseNames([]);
+                          setDatabaseLoadError('');
+                        }}
+                      />
+                    </div>
+                  </Tooltip>
+                </div>
+
+                <div>
+                  <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', gap: 12, marginBottom: 6 }}>
+                    <div style={{ fontSize: 12, color: secondaryTextColor }}>数据库</div>
+                    <div style={{ display: 'flex', gap: 8 }}>
+                      <Button
+                        size="small"
+                        type="text"
+                        disabled={availableDatabases.length === 0}
+                        onClick={() => setSelectedDatabaseNames(availableDatabases.map((item) => item.value))}
+                      >
+                        全选
+                      </Button>
+                      <Button
+                        size="small"
+                        type="text"
+                        disabled={selectedDatabaseNames.length === 0}
+                        onClick={() => setSelectedDatabaseNames([])}
+                      >
+                        清空
+                      </Button>
+                    </div>
+                  </div>
+                  <Select
+                    style={{ width: '100%' }}
+                    mode="multiple"
+                    value={selectedDatabaseNames}
+                    placeholder={loadingDatabases ? '正在加载数据库...' : '选择数据库'}
+                    loading={loadingDatabases}
+                    options={availableDatabases}
+                    showSearch
+                    optionFilterProp="title"
+                    filterOption={filterOptionByLabel as any}
+                    maxTagCount="responsive"
+                    onChange={(next) => setSelectedDatabaseNames((next as string[]).map((item) => String(item).trim()).filter(Boolean))}
+                  />
+                  <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
+                    将在开始导出时先选择输出目录，再为每个数据库分别生成独立的 SQL 文件。
+                  </div>
+                </div>
+
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>导出内容</div>
+                  <Select
+                    style={{ width: '100%' }}
+                    value={batchDatabaseMode}
+                    options={BATCH_DATABASE_EXPORT_MODE_OPTIONS.map((item) => ({ value: item.value, label: item.label }))}
+                    onChange={(next) => setBatchDatabaseMode(next as BatchDatabaseExportMode)}
+                  />
+                  <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
+                    {batchDatabaseModeMeta.description}
+                  </div>
+                </div>
+
+                <div>
+                  <div style={{ marginBottom: 6, fontSize: 12, color: secondaryTextColor }}>导出格式</div>
+                  <Select
+                    style={{ width: '100%' }}
+                    value="sql"
+                    disabled
+                    options={[{ value: 'sql', label: 'SQL 文件' }]}
+                  />
+                </div>
+              </>
+            )}
           </div>
 
-          {scope !== 'all' && !activeScopeQuery ? (
+          {isSingleWorkbench && scope !== 'all' && !activeScopeQuery ? (
             <Alert
               type="info"
               showIcon
@@ -498,14 +1149,22 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
             }}
           >
             <div style={{ display: 'grid', gridTemplateColumns: '96px minmax(0, 1fr)', rowGap: 6, columnGap: 8 }}>
-              <Text type="secondary">预计行数</Text>
-              <Text>{typeof activeScopeRowCount === 'number' ? activeScopeRowCount.toLocaleString() : '当前未预先统计'}</Text>
+              <Text type="secondary">{isSingleWorkbench ? '预计行数' : (isBatchDatabasesWorkbench ? '已选数据库' : '已选对象')}</Text>
+              <Text>
+                {typeof activeScopeCount === 'number'
+                  ? activeScopeCount.toLocaleString()
+                  : '当前未预先统计'}
+              </Text>
 
               <Text type="secondary">执行链路</Text>
               <Text>{exportStrategyLabel}</Text>
             </div>
             <div style={{ fontSize: 12, color: secondaryTextColor }}>
-              导出开始后会先选择目标文件，再在右侧主面板展示唯一进度条、导出耗时和输出路径。
+              {isSingleWorkbench
+                ? '导出开始后会先选择目标文件，再在右侧主面板展示唯一进度条、导出耗时和输出路径。'
+                : isBatchTablesWorkbench
+                  ? '批量对象导出会统一生成一个 SQL 文件，并在右侧展示整体对象进度与最近任务摘要。'
+                  : '批量库导出会先选择输出目录，再按库生成独立 SQL 文件，并在右侧展示整体库进度。'}
             </div>
             <Button
               type="primary"
@@ -541,12 +1200,12 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
                   <div style={{ fontSize: 13, fontWeight: 600, color: headingColor }}>当前任务</div>
                   {renderStatusPill(progressState.status)}
                 </div>
-                  <Title level={5} style={{ margin: '10px 0 0', color: headingColor }}>
-                    {progressState.title || `导出 ${tab.tableName || '未命名对象'}`}
-                  </Title>
+                <Title level={5} style={{ margin: '10px 0 0', color: headingColor }}>
+                  {progressState.title || tab.title || '导出任务'}
+                </Title>
                 <div style={{ marginTop: 6, color: secondaryTextColor, fontSize: 13 }}>
                   {progressState.jobId
-                    ? `${progressState.targetName || tab.tableName || '-'} · ${currentScopeLabel} · ${progressState.format || String(format).toUpperCase()}`
+                    ? `${progressState.targetName || fallbackTargetName} · ${currentScopeLabel} · ${progressState.format || fallbackFormat}`
                     : '开始导出后，这里会展示当前任务的唯一主进度。'}
                 </div>
               </div>
@@ -599,19 +1258,19 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
                       {progressState.stage || STATUS_META[progressState.status]?.label || '等待开始'}
                     </Text>
                     <div style={{ fontSize: 12, color: secondaryTextColor, margin: '12px 0 6px' }}>进度说明</div>
-                    <Text>{formatExportProgressRows(progressState.current, progressState.total, progressState.totalRowsKnown)}</Text>
-                    {!progressState.totalRowsKnown && progressState.status !== 'done' && progressState.status !== 'error' ? (
+                    <Text>{currentProgressSummary}</Text>
+                    {currentProgressHint ? (
                       <div style={{ marginTop: 6, fontSize: 12, color: secondaryTextColor }}>
-                        当前未预先统计总行数，暂不显示百分比，写入行数为实时值。
+                        {currentProgressHint}
                       </div>
                     ) : null}
                   </div>
                   <div>
-                    <div style={{ fontSize: 12, color: secondaryTextColor, marginBottom: 6 }}>输出文件</div>
+                    <div style={{ fontSize: 12, color: secondaryTextColor, marginBottom: 6 }}>{progressOutputLabel}</div>
                     {progressState.filePath ? (
                       <Paragraph style={{ marginBottom: 0, wordBreak: 'break-all' }}>{progressState.filePath}</Paragraph>
                     ) : (
-                      <Text type="secondary">等待选择目标文件路径</Text>
+                      <Text type="secondary">等待选择目标路径</Text>
                     )}
                   </div>
                 </div>
@@ -689,7 +1348,7 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
                         {entry.stage || STATUS_META[entry.status].label}
                       </div>
                       <div style={{ marginTop: 4, fontSize: 12, color: secondaryTextColor }}>
-                        {formatExportProgressRows(entry.current, entry.total, entry.totalRowsKnown)}
+                        {formatWorkbenchProgressSummary(workbenchMode, entry.current, entry.total, entry.totalRowsKnown)}
                       </div>
                       {entry.message ? (
                         <div style={{ marginTop: 8, fontSize: 12, color: '#dc2626' }}>{entry.message}</div>
@@ -704,7 +1363,7 @@ const TableExportWorkbench: React.FC<{ tab: TabData }> = ({ tab }) => {
                         <Text type="secondary">导出耗时</Text>
                         <Text>{formatExportElapsed(resolveExportElapsedMs(entry.startedAt, entry.finishedAt, nowTick))}</Text>
 
-                        <Text type="secondary">文件</Text>
+                        <Text type="secondary">{isBatchDatabasesWorkbench ? '目录' : '文件'}</Text>
                         <Paragraph style={{ marginBottom: 0, wordBreak: 'break-all' }}>
                           {entry.filePath || '-'}
                         </Paragraph>
diff --git a/frontend/src/types.ts b/frontend/src/types.ts
index 527c2e2..c01860d 100644
--- a/frontend/src/types.ts
+++ b/frontend/src/types.ts
@@ -472,6 +472,7 @@ export interface TabData {
   sidebarLocateKey?: string; // Precise sidebar tree key for locating an object node
   savedQueryId?: string; // Saved query identity for quick-save behavior
   objectType?: 'table' | 'view' | 'materialized-view'; // Table-like object type for shared viewers
+  exportWorkbenchMode?: 'single' | 'batch-tables' | 'batch-databases';
   tableExportScopeOptions?: TableExportScopeOption[];
   tableExportInitialScope?: TableExportScope;
   tableExportQueryByScope?: Partial<Record<TableExportScope, string>>;
diff --git a/frontend/src/utils/tableExportTab.test.ts b/frontend/src/utils/tableExportTab.test.ts
index 3966152..08543cb 100644
--- a/frontend/src/utils/tableExportTab.test.ts
+++ b/frontend/src/utils/tableExportTab.test.ts
@@ -1,6 +1,9 @@
 import { describe, expect, it } from 'vitest';
 
 import {
+  buildBatchDatabaseExportWorkbenchTab,
+  buildBatchTableExportWorkbenchTab,
+  buildExportWorkbenchHistoryKey,
   buildTableExportHistoryKey,
   buildTableExportTab,
   DEFAULT_TABLE_EXPORT_SCOPE_OPTION,
@@ -11,6 +14,20 @@ describe('tableExportTab', () => {
     expect(buildTableExportHistoryKey(' conn-1 ', ' app ', ' public.orders ')).toBe('conn-1::app::public.orders');
   });
 
+  it('builds batch workbench history keys by mode', () => {
+    expect(buildExportWorkbenchHistoryKey({
+      connectionId: ' conn-1 ',
+      dbName: ' app ',
+      tableName: 'orders',
+      exportWorkbenchMode: 'batch-tables',
+    })).toBe('conn-1::app::__batch_tables__');
+    expect(buildExportWorkbenchHistoryKey({
+      connectionId: ' conn-1 ',
+      dbName: ' ignored ',
+      exportWorkbenchMode: 'batch-databases',
+    })).toBe('conn-1::__batch_databases__');
+  });
+
   it('builds a stable table export tab with normalized defaults', () => {
     const tab = buildTableExportTab({
       connectionId: 'conn-1',
@@ -21,6 +38,7 @@ describe('tableExportTab', () => {
     expect(tab.id).toBe('table-export-conn-1-app-public.orders');
     expect(tab.type).toBe('table-export');
     expect(tab.title).toBe('导出 public.orders');
+    expect(tab.exportWorkbenchMode).toBe('single');
     expect(tab.tableExportScopeOptions).toEqual([DEFAULT_TABLE_EXPORT_SCOPE_OPTION]);
     expect(tab.tableExportInitialScope).toBe('all');
     expect(tab.tableExportQueryByScope).toBeUndefined();
@@ -60,4 +78,28 @@ describe('tableExportTab', () => {
       filteredAll: 42,
     });
   });
+
+  it('builds batch table export workbench tabs with stable ids', () => {
+    const tab = buildBatchTableExportWorkbenchTab({
+      connectionId: 'conn-1',
+      dbName: 'SYS',
+    });
+
+    expect(tab.id).toBe('table-export-batch-tables-conn-1-SYS');
+    expect(tab.type).toBe('table-export');
+    expect(tab.title).toBe('批量导出对象');
+    expect(tab.exportWorkbenchMode).toBe('batch-tables');
+    expect(tab.dbName).toBe('SYS');
+  });
+
+  it('builds batch database export workbench tabs with stable ids', () => {
+    const tab = buildBatchDatabaseExportWorkbenchTab({
+      connectionId: 'conn-1',
+    });
+
+    expect(tab.id).toBe('table-export-batch-databases-conn-1');
+    expect(tab.type).toBe('table-export');
+    expect(tab.title).toBe('批量导出库');
+    expect(tab.exportWorkbenchMode).toBe('batch-databases');
+  });
 });
diff --git a/frontend/src/utils/tableExportTab.ts b/frontend/src/utils/tableExportTab.ts
index 93d127e..592e5ec 100644
--- a/frontend/src/utils/tableExportTab.ts
+++ b/frontend/src/utils/tableExportTab.ts
@@ -18,6 +18,21 @@ export const buildTableExportHistoryKey = (
   ].join('::');
 };
 
+export const buildExportWorkbenchHistoryKey = (
+  input: Pick<TabData, 'connectionId' | 'dbName' | 'tableName' | 'exportWorkbenchMode'>,
+): string => {
+  const mode = input.exportWorkbenchMode || 'single';
+  const connectionId = String(input.connectionId || '').trim();
+  const dbName = String(input.dbName || '').trim();
+  if (mode === 'batch-tables') {
+    return [connectionId, dbName, '__batch_tables__'].join('::');
+  }
+  if (mode === 'batch-databases') {
+    return [connectionId, '__batch_databases__'].join('::');
+  }
+  return buildTableExportHistoryKey(connectionId, dbName, input.tableName);
+};
+
 type BuildTableExportTabInput = {
   connectionId: string;
   dbName?: string;
@@ -32,6 +47,17 @@ type BuildTableExportTabInput = {
   rowCountByScope?: Partial<Record<TableExportScope, number>>;
 };
 
+type BuildBatchTableExportWorkbenchTabInput = {
+  connectionId: string;
+  dbName?: string;
+  title?: string;
+};
+
+type BuildBatchDatabaseExportWorkbenchTabInput = {
+  connectionId: string;
+  title?: string;
+};
+
 const normalizeScopeOptions = (
   scopeOptions: TableExportScopeOption[] | undefined,
 ): TableExportScopeOption[] => {
@@ -108,6 +134,7 @@ export const buildTableExportTab = (input: BuildTableExportTabInput): TabData =>
     id: `table-export-${connectionId}-${dbName}-${tableName}`,
     title: String(input.title || `导出 ${objectLabel}`).trim() || `导出 ${objectLabel}`,
     type: 'table-export',
+    exportWorkbenchMode: 'single',
     connectionId,
     dbName,
     tableName,
@@ -121,3 +148,34 @@ export const buildTableExportTab = (input: BuildTableExportTabInput): TabData =>
     tableExportRowCountByScope: normalizeRowCountByScope(input.rowCountByScope),
   };
 };
+
+export const buildBatchTableExportWorkbenchTab = (
+  input: BuildBatchTableExportWorkbenchTabInput,
+): TabData => {
+  const connectionId = String(input.connectionId || '').trim();
+  const dbName = String(input.dbName || '').trim();
+  const scopeSuffix = dbName || 'all';
+  return {
+    id: `table-export-batch-tables-${connectionId || 'none'}-${scopeSuffix}`,
+    title: String(input.title || '批量导出对象').trim() || '批量导出对象',
+    type: 'table-export',
+    exportWorkbenchMode: 'batch-tables',
+    connectionId,
+    dbName: dbName || undefined,
+    initialTab: 'config',
+  };
+};
+
+export const buildBatchDatabaseExportWorkbenchTab = (
+  input: BuildBatchDatabaseExportWorkbenchTabInput,
+): TabData => {
+  const connectionId = String(input.connectionId || '').trim();
+  return {
+    id: `table-export-batch-databases-${connectionId || 'none'}`,
+    title: String(input.title || '批量导出库').trim() || '批量导出库',
+    type: 'table-export',
+    exportWorkbenchMode: 'batch-databases',
+    connectionId,
+    initialTab: 'config',
+  };
+};
diff --git a/frontend/wailsjs/go/app/App.d.ts b/frontend/wailsjs/go/app/App.d.ts
index d5e9cb4..40d2c0d 100755
--- a/frontend/wailsjs/go/app/App.d.ts
+++ b/frontend/wailsjs/go/app/App.d.ts
@@ -110,6 +110,8 @@ export function ExportDataWithOptions(arg1:Array<Record<string, any>>,arg2:Array
 
 export function ExportDatabaseSQL(arg1:connection.ConnectionConfig,arg2:string,arg3:boolean):Promise<connection.QueryResult>;
 
+export function ExportDatabasesSQLWithOptions(arg1:connection.ConnectionConfig,arg2:Array<string>,arg3:boolean,arg4:app.ExportFileOptions):Promise<connection.QueryResult>;
+
 export function ExportQuery(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string,arg5:string):Promise<connection.QueryResult>;
 
 export function ExportQueryWithOptions(arg1:connection.ConnectionConfig,arg2:string,arg3:string,arg4:string,arg5:app.ExportFileOptions):Promise<connection.QueryResult>;
@@ -126,6 +128,8 @@ export function ExportTablesDataSQL(arg1:connection.ConnectionConfig,arg2:string
 
 export function ExportTablesSQL(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>,arg4:boolean):Promise<connection.QueryResult>;
 
+export function ExportTablesSQLWithOptions(arg1:connection.ConnectionConfig,arg2:string,arg3:Array<string>,arg4:boolean,arg5:boolean,arg6:app.ExportFileOptions):Promise<connection.QueryResult>;
+
 export function GenerateQueryID():Promise<string>;
 
 export function GetAppInfo():Promise<connection.QueryResult>;
diff --git a/frontend/wailsjs/go/app/App.js b/frontend/wailsjs/go/app/App.js
index c85c874..410ec6d 100755
--- a/frontend/wailsjs/go/app/App.js
+++ b/frontend/wailsjs/go/app/App.js
@@ -210,6 +210,10 @@ export function ExportDatabaseSQL(arg1, arg2, arg3) {
   return window['go']['app']['App']['ExportDatabaseSQL'](arg1, arg2, arg3);
 }
 
+export function ExportDatabasesSQLWithOptions(arg1, arg2, arg3, arg4) {
+  return window['go']['app']['App']['ExportDatabasesSQLWithOptions'](arg1, arg2, arg3, arg4);
+}
+
 export function ExportQuery(arg1, arg2, arg3, arg4, arg5) {
   return window['go']['app']['App']['ExportQuery'](arg1, arg2, arg3, arg4, arg5);
 }
@@ -242,6 +246,10 @@ export function ExportTablesSQL(arg1, arg2, arg3, arg4) {
   return window['go']['app']['App']['ExportTablesSQL'](arg1, arg2, arg3, arg4);
 }
 
+export function ExportTablesSQLWithOptions(arg1, arg2, arg3, arg4, arg5, arg6) {
+  return window['go']['app']['App']['ExportTablesSQLWithOptions'](arg1, arg2, arg3, arg4, arg5, arg6);
+}
+
 export function GenerateQueryID() {
   return window['go']['app']['App']['GenerateQueryID']();
 }
diff --git a/internal/app/methods_file.go b/internal/app/methods_file.go
index 3a78af6..4df9f1a 100644
--- a/internal/app/methods_file.go
+++ b/internal/app/methods_file.go
@@ -39,6 +39,8 @@ const sqlFileProgressTimeInterval = time.Second
 const exportProgressEvent = "export:progress"
 const exportProgressRowInterval int64 = 1000
 const exportProgressTimeInterval = 500 * time.Millisecond
+const sqlExportInsertBatchMaxRows = 200
+const sqlExportInsertBatchMaxBytes = 256 * 1024
 const defaultAppLogTailLineLimit = 80
 const maxAppLogTailLineLimit = 200
 const appLogTailReadWindowBytes int64 = 256 * 1024
@@ -220,6 +222,89 @@ func (r *exportProgressReporter) Error(current int64, message string) {
 	r.emit("error", "导出失败", current, message, true)
 }
 
+var exportFileNameSanitizer = strings.NewReplacer(
+	"/", "_",
+	"\\", "_",
+	":", "_",
+	"*", "_",
+	"?", "_",
+	"\"", "_",
+	"<", "_",
+	">", "_",
+	"|", "_",
+)
+
+func sanitizeExportFileStem(raw string) string {
+	value := strings.TrimSpace(raw)
+	if value == "" {
+		return "export"
+	}
+	value = exportFileNameSanitizer.Replace(value)
+	value = strings.Trim(value, ". ")
+	if value == "" {
+		return "export"
+	}
+	return value
+}
+
+func resolveSQLExportSuffix(includeSchema bool, includeData bool) string {
+	if includeSchema && includeData {
+		return "backup"
+	}
+	if includeData {
+		return "data"
+	}
+	return "schema"
+}
+
+func normalizeExportNameList(names []string) []string {
+	normalized := make([]string, 0, len(names))
+	seen := make(map[string]struct{}, len(names))
+	for _, name := range names {
+		safeName := strings.TrimSpace(name)
+		if safeName == "" {
+			continue
+		}
+		if _, ok := seen[safeName]; ok {
+			continue
+		}
+		seen[safeName] = struct{}{}
+		normalized = append(normalized, safeName)
+	}
+	return normalized
+}
+
+func buildTablesExportDefaultFilename(dbName string, objectNames []string, includeSchema bool, includeData bool) string {
+	suffix := resolveSQLExportSuffix(includeSchema, includeData)
+	if len(objectNames) == 1 {
+		return fmt.Sprintf("%s_%s.sql", sanitizeExportFileStem(objectNames[0]), suffix)
+	}
+	safeDbName := strings.TrimSpace(dbName)
+	if safeDbName == "" {
+		safeDbName = "export"
+	}
+	return fmt.Sprintf("%s_%s_%dtables.sql", sanitizeExportFileStem(safeDbName), suffix, len(objectNames))
+}
+
+func buildDatabaseExportDefaultFilename(dbName string, includeData bool) string {
+	suffix := "schema"
+	if includeData {
+		suffix = "backup"
+	}
+	return fmt.Sprintf("%s_%s.sql", sanitizeExportFileStem(dbName), suffix)
+}
+
+func resolveBatchObjectsTargetName(dbName string, objectNames []string) string {
+	if len(objectNames) == 1 {
+		return objectNames[0]
+	}
+	safeDbName := strings.TrimSpace(dbName)
+	if safeDbName == "" {
+		safeDbName = "当前数据库"
+	}
+	return fmt.Sprintf("%s · %d 个对象", safeDbName, len(objectNames))
+}
+
 func normalizeSQLDirectoryPath(directoryPath string) (string, error) {
 	target := strings.TrimSpace(directoryPath)
 	if target == "" {
@@ -2246,58 +2331,85 @@ func (a *App) ExportTablesDataSQL(config connection.ConnectionConfig, dbName str
 	return a.exportTablesSQL(config, dbName, tableNames, false, true)
 }
 
-func (a *App) exportTablesSQL(config connection.ConnectionConfig, dbName string, tableNames []string, includeSchema bool, includeData bool) connection.QueryResult {
+func (a *App) ExportTablesSQLWithOptions(
+	config connection.ConnectionConfig,
+	dbName string,
+	tableNames []string,
+	includeSchema bool,
+	includeData bool,
+	options ExportFileOptions,
+) connection.QueryResult {
 	if !includeSchema && !includeData {
 		return connection.QueryResult{Success: false, Message: "无效的导出模式"}
 	}
 
-	safeDbName := strings.TrimSpace(dbName)
-	if safeDbName == "" {
-		safeDbName = "export"
-	}
-	suffix := "schema"
-	if includeSchema && includeData {
-		suffix = "backup"
-	} else if !includeSchema && includeData {
-		suffix = "data"
-	}
-	defaultFilename := fmt.Sprintf("%s_%s_%dtables.sql", safeDbName, suffix, len(tableNames))
-	if len(tableNames) == 1 && strings.TrimSpace(tableNames[0]) != "" {
-		defaultFilename = fmt.Sprintf("%s_%s.sql", strings.TrimSpace(tableNames[0]), suffix)
-	}
+	objects := normalizeExportNameList(tableNames)
+	options = normalizeExportFileOptions("sql", options)
+	options.TotalRowsHint = int64(len(objects))
+	options.TotalRowsKnown = true
 
 	filename, err := runtime.SaveFileDialog(a.ctx, runtime.SaveDialogOptions{
 		Title:           "Export Tables (SQL)",
-		DefaultFilename: defaultFilename,
+		DefaultFilename: buildTablesExportDefaultFilename(dbName, objects, includeSchema, includeData),
 	})
 	if err != nil || filename == "" {
 		return connection.QueryResult{Success: false, Message: "已取消"}
 	}
 
+	reporter := newExportProgressReporter(a, options, resolveBatchObjectsTargetName(dbName, objects), filename)
+	if reporter != nil {
+		reporter.Start("正在准备批量对象导出")
+	}
+	return a.exportTablesSQLToFile(config, dbName, objects, includeSchema, includeData, filename, reporter)
+}
+
+func (a *App) exportTablesSQL(config connection.ConnectionConfig, dbName string, tableNames []string, includeSchema bool, includeData bool) connection.QueryResult {
+	if !includeSchema && !includeData {
+		return connection.QueryResult{Success: false, Message: "无效的导出模式"}
+	}
+	objects := normalizeExportNameList(tableNames)
+
+	filename, err := runtime.SaveFileDialog(a.ctx, runtime.SaveDialogOptions{
+		Title:           "Export Tables (SQL)",
+		DefaultFilename: buildTablesExportDefaultFilename(dbName, objects, includeSchema, includeData),
+	})
+	if err != nil || filename == "" {
+		return connection.QueryResult{Success: false, Message: "已取消"}
+	}
+
+	return a.exportTablesSQLToFile(config, dbName, objects, includeSchema, includeData, filename, nil)
+}
+
+func (a *App) exportTablesSQLToFile(
+	config connection.ConnectionConfig,
+	dbName string,
+	tableNames []string,
+	includeSchema bool,
+	includeData bool,
+	filename string,
+	reporter *exportProgressReporter,
+) connection.QueryResult {
+	if !includeSchema && !includeData {
+		return connection.QueryResult{Success: false, Message: "无效的导出模式"}
+	}
+
 	runConfig := normalizeRunConfig(config, dbName)
 	dbInst, err := a.getDatabase(runConfig)
 	if err != nil {
+		if reporter != nil {
+			reporter.Error(0, err.Error())
+		}
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
 
-	objects := make([]string, 0, len(tableNames))
-	seen := make(map[string]struct{}, len(tableNames))
-	for _, t := range tableNames {
-		t = strings.TrimSpace(t)
-		if t == "" {
-			continue
-		}
-		if _, ok := seen[t]; ok {
-			continue
-		}
-		seen[t] = struct{}{}
-		objects = append(objects, t)
-	}
 	viewLookup := listViewNameLookup(dbInst, runConfig, dbName)
-	objects = buildExportObjectOrder(runConfig, dbName, objects, viewLookup, false)
+	objects := buildExportObjectOrder(runConfig, dbName, normalizeExportNameList(tableNames), viewLookup, false)
 
 	f, err := os.Create(filename)
 	if err != nil {
+		if reporter != nil {
+			reporter.Error(0, err.Error())
+		}
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
 	defer f.Close()
@@ -2306,18 +2418,44 @@ func (a *App) exportTablesSQL(config connection.ConnectionConfig, dbName string,
 	defer w.Flush()
 
 	if err := writeSQLHeader(w, runConfig, dbName); err != nil {
+		if reporter != nil {
+			reporter.Error(0, err.Error())
+		}
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
-	for _, objectName := range objects {
+	for index, objectName := range objects {
+		if reporter != nil {
+			reporter.ForceRunning(int64(index), fmt.Sprintf("正在导出 %s (%d/%d)", objectName, index+1, len(objects)))
+		}
 		if err := dumpTableSQL(w, dbInst, runConfig, dbName, objectName, includeSchema, includeData, viewLookup); err != nil {
+			if reporter != nil {
+				reporter.Error(int64(index), err.Error())
+			}
 			return connection.QueryResult{Success: false, Message: err.Error()}
 		}
+		if reporter != nil {
+			reporter.ForceRunning(int64(index+1), fmt.Sprintf("正在导出 %s (%d/%d)", objectName, index+1, len(objects)))
+		}
 	}
 	if err := writeSQLFooter(w, runConfig); err != nil {
+		if reporter != nil {
+			reporter.Error(int64(len(objects)), err.Error())
+		}
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
 
-	return connection.QueryResult{Success: true, Message: "导出完成"}
+	if reporter != nil {
+		reporter.Finalizing(int64(len(objects)))
+		reporter.Done(int64(len(objects)))
+	}
+	return connection.QueryResult{
+		Success: true,
+		Message: "导出完成",
+		Data: map[string]interface{}{
+			"filePath":    filename,
+			"objectCount": len(objects),
+		},
+	}
 }
 
 func (a *App) ExportDatabaseSQL(config connection.ConnectionConfig, dbName string, includeData bool) connection.QueryResult {
@@ -2325,19 +2463,87 @@ func (a *App) ExportDatabaseSQL(config connection.ConnectionConfig, dbName strin
 	if safeDbName == "" {
 		return connection.QueryResult{Success: false, Message: "数据库名称不能为空"}
 	}
-	suffix := "schema"
-	if includeData {
-		suffix = "backup"
-	}
 
 	filename, err := runtime.SaveFileDialog(a.ctx, runtime.SaveDialogOptions{
 		Title:           fmt.Sprintf("Export %s (SQL)", safeDbName),
-		DefaultFilename: fmt.Sprintf("%s_%s.sql", safeDbName, suffix),
+		DefaultFilename: buildDatabaseExportDefaultFilename(safeDbName, includeData),
 	})
 	if err != nil || filename == "" {
 		return connection.QueryResult{Success: false, Message: "已取消"}
 	}
 
+	return a.exportDatabaseSQLToFile(config, safeDbName, includeData, filename)
+}
+
+func (a *App) ExportDatabasesSQLWithOptions(
+	config connection.ConnectionConfig,
+	dbNames []string,
+	includeData bool,
+	options ExportFileOptions,
+) connection.QueryResult {
+	normalizedDbNames := normalizeExportNameList(dbNames)
+	if len(normalizedDbNames) == 0 {
+		return connection.QueryResult{Success: false, Message: "请至少选择一个数据库"}
+	}
+
+	directory, err := runtime.OpenDirectoryDialog(a.ctx, runtime.OpenDialogOptions{
+		Title:            "选择批量导出目录",
+		DefaultDirectory: normalizeDirectoryDialogPath(""),
+	})
+	if err != nil || strings.TrimSpace(directory) == "" {
+		return connection.QueryResult{Success: false, Message: "已取消"}
+	}
+
+	options = normalizeExportFileOptions("sql", options)
+	options.TotalRowsHint = int64(len(normalizedDbNames))
+	options.TotalRowsKnown = true
+	reporter := newExportProgressReporter(a, options, fmt.Sprintf("%d 个数据库", len(normalizedDbNames)), directory)
+	if reporter != nil {
+		reporter.Start("正在准备批量库导出")
+	}
+
+	for index, name := range normalizedDbNames {
+		if reporter != nil {
+			reporter.ForceRunning(int64(index), fmt.Sprintf("正在导出 %s (%d/%d)", name, index+1, len(normalizedDbNames)))
+		}
+		targetFile := filepath.Join(directory, buildDatabaseExportDefaultFilename(name, includeData))
+		result := a.exportDatabaseSQLToFile(config, name, includeData, targetFile)
+		if !result.Success {
+			if reporter != nil {
+				reporter.Error(int64(index), result.Message)
+			}
+			return result
+		}
+		if reporter != nil {
+			reporter.ForceRunning(int64(index+1), fmt.Sprintf("正在导出 %s (%d/%d)", name, index+1, len(normalizedDbNames)))
+		}
+	}
+
+	if reporter != nil {
+		reporter.Finalizing(int64(len(normalizedDbNames)))
+		reporter.Done(int64(len(normalizedDbNames)))
+	}
+	return connection.QueryResult{
+		Success: true,
+		Message: "导出完成",
+		Data: map[string]interface{}{
+			"directoryPath": directory,
+			"fileCount":     len(normalizedDbNames),
+		},
+	}
+}
+
+func (a *App) exportDatabaseSQLToFile(
+	config connection.ConnectionConfig,
+	dbName string,
+	includeData bool,
+	filename string,
+) connection.QueryResult {
+	safeDbName := strings.TrimSpace(dbName)
+	if safeDbName == "" {
+		return connection.QueryResult{Success: false, Message: "数据库名称不能为空"}
+	}
+
 	runConfig := normalizeRunConfig(config, dbName)
 	dbInst, err := a.getDatabase(runConfig)
 	if err != nil {
@@ -2372,7 +2578,13 @@ func (a *App) ExportDatabaseSQL(config connection.ConnectionConfig, dbName strin
 		return connection.QueryResult{Success: false, Message: err.Error()}
 	}
 
-	return connection.QueryResult{Success: true, Message: "导出完成"}
+	return connection.QueryResult{
+		Success: true,
+		Message: "导出完成",
+		Data: map[string]interface{}{
+			"filePath": filename,
+		},
+	}
 }
 
 func (a *App) ExportSchemaSQL(config connection.ConnectionConfig, dbName string, schemaName string, includeData bool) connection.QueryResult {
@@ -3350,6 +3562,12 @@ func dumpTableSQL(
 		columnTypeMap: columnTypeMap,
 	}
 	if err := streamQueryDataForExport(dbInst, config, selectSQL, insertConsumer); err != nil {
+		if flushErr := insertConsumer.Flush(); flushErr != nil {
+			return flushErr
+		}
+		return err
+	}
+	if err := insertConsumer.Flush(); err != nil {
 		return err
 	}
 	if insertConsumer.rowCount == 0 {
@@ -4039,9 +4257,32 @@ type sqlInsertExportConsumer struct {
 	columnTypeMap map[string]string
 	columns       []string
 	quotedCols    []string
+	columnList    string
 	columnTypes   []string
 	valueBuf      []string
 	rowCount      int64
+	mode          sqlInsertExportMode
+	pendingRows   int
+	statementBuf  strings.Builder
+}
+
+type sqlInsertExportMode int
+
+const (
+	sqlInsertExportModeSingle sqlInsertExportMode = iota
+	sqlInsertExportModeMultiValues
+	sqlInsertExportModeInsertAll
+)
+
+func resolveSQLInsertExportMode(dbType string) sqlInsertExportMode {
+	switch strings.ToLower(strings.TrimSpace(dbType)) {
+	case "mysql", "mariadb", "oceanbase", "diros", "starrocks", "sphinx", "postgres", "kingbase", "highgo", "vastbase", "opengauss", "gaussdb", "sqlserver", "sqlite", "duckdb", "clickhouse", "iris":
+		return sqlInsertExportModeMultiValues
+	case "oracle", "dameng":
+		return sqlInsertExportModeInsertAll
+	default:
+		return sqlInsertExportModeSingle
+	}
 }
 
 func (c *sqlInsertExportConsumer) SetColumns(columns []string) error {
@@ -4055,19 +4296,16 @@ func (c *sqlInsertExportConsumer) SetColumns(columns []string) error {
 	for i, column := range columns {
 		c.columnTypes[i] = c.columnTypeMap[normalizeColumnName(column)]
 	}
+	c.columnList = strings.Join(c.quotedCols, ", ")
+	c.mode = resolveSQLInsertExportMode(c.dbType)
 	return nil
 }
 
 func (c *sqlInsertExportConsumer) ConsumeRow(row map[string]interface{}) error {
-	values := make([]string, 0, len(c.columns))
-	for _, column := range c.columns {
-		values = append(values, formatImportSQLValue(c.dbType, c.columnTypeMap[normalizeColumnName(column)], row[column]))
+	for i, column := range c.columns {
+		c.valueBuf[i] = formatImportSQLValue(c.dbType, c.columnTypeMap[normalizeColumnName(column)], row[column])
 	}
-	if _, err := c.w.WriteString(fmt.Sprintf("INSERT INTO %s (%s) VALUES (%s);\n", c.quotedTable, strings.Join(c.quotedCols, ", "), strings.Join(values, ", "))); err != nil {
-		return err
-	}
-	c.rowCount++
-	return nil
+	return c.consumeValueBuf()
 }
 
 func (c *sqlInsertExportConsumer) ConsumeRowValues(values []interface{}) error {
@@ -4078,10 +4316,92 @@ func (c *sqlInsertExportConsumer) ConsumeRowValues(values []interface{}) error {
 		}
 		c.valueBuf[i] = formatImportSQLValue(c.dbType, c.columnTypes[i], value)
 	}
-	if _, err := c.w.WriteString(fmt.Sprintf("INSERT INTO %s (%s) VALUES (%s);\n", c.quotedTable, strings.Join(c.quotedCols, ", "), strings.Join(c.valueBuf, ", "))); err != nil {
+	return c.consumeValueBuf()
+}
+
+func (c *sqlInsertExportConsumer) consumeValueBuf() error {
+	rowValues := "(" + strings.Join(c.valueBuf, ", ") + ")"
+	switch c.mode {
+	case sqlInsertExportModeMultiValues, sqlInsertExportModeInsertAll:
+		return c.appendBatchRow(rowValues)
+	default:
+		if _, err := c.w.WriteString(fmt.Sprintf("INSERT INTO %s (%s) VALUES %s;\n", c.quotedTable, c.columnList, rowValues)); err != nil {
+			return err
+		}
+		c.rowCount++
+		return nil
+	}
+}
+
+func (c *sqlInsertExportConsumer) appendBatchRow(rowValues string) error {
+	if c.pendingRows > 0 {
+		separatorLen := 2
+		if c.mode == sqlInsertExportModeInsertAll {
+			separatorLen = 3
+		}
+		if c.pendingRows >= sqlExportInsertBatchMaxRows || c.statementBuf.Len()+len(rowValues)+separatorLen >= sqlExportInsertBatchMaxBytes {
+			if err := c.Flush(); err != nil {
+				return err
+			}
+		}
+	}
+
+	switch c.mode {
+	case sqlInsertExportModeMultiValues:
+		if c.pendingRows == 0 {
+			c.statementBuf.WriteString("INSERT INTO ")
+			c.statementBuf.WriteString(c.quotedTable)
+			c.statementBuf.WriteString(" (")
+			c.statementBuf.WriteString(c.columnList)
+			c.statementBuf.WriteString(") VALUES ")
+		} else {
+			c.statementBuf.WriteString(",\n")
+		}
+		c.statementBuf.WriteString(rowValues)
+	case sqlInsertExportModeInsertAll:
+		if c.pendingRows == 0 {
+			c.statementBuf.WriteString("INSERT ALL\n")
+		}
+		c.statementBuf.WriteString("  INTO ")
+		c.statementBuf.WriteString(c.quotedTable)
+		c.statementBuf.WriteString(" (")
+		c.statementBuf.WriteString(c.columnList)
+		c.statementBuf.WriteString(") VALUES ")
+		c.statementBuf.WriteString(rowValues)
+		c.statementBuf.WriteByte('\n')
+	default:
+		if _, err := c.w.WriteString(fmt.Sprintf("INSERT INTO %s (%s) VALUES %s;\n", c.quotedTable, c.columnList, rowValues)); err != nil {
+			return err
+		}
+		c.rowCount++
+		return nil
+	}
+
+	c.pendingRows++
+	if c.pendingRows >= sqlExportInsertBatchMaxRows || c.statementBuf.Len() >= sqlExportInsertBatchMaxBytes {
+		return c.Flush()
+	}
+	return nil
+}
+
+func (c *sqlInsertExportConsumer) Flush() error {
+	if c == nil || c.pendingRows == 0 {
+		return nil
+	}
+	switch c.mode {
+	case sqlInsertExportModeMultiValues:
+		c.statementBuf.WriteString(";\n")
+	case sqlInsertExportModeInsertAll:
+		c.statementBuf.WriteString("SELECT 1 FROM DUAL;\n")
+	default:
+		return nil
+	}
+	if _, err := c.w.WriteString(c.statementBuf.String()); err != nil {
 		return err
 	}
-	c.rowCount++
+	c.rowCount += int64(c.pendingRows)
+	c.pendingRows = 0
+	c.statementBuf.Reset()
 	return nil
 }
 
diff --git a/internal/app/methods_file_export_test.go b/internal/app/methods_file_export_test.go
index 903ec17..df66877 100644
--- a/internal/app/methods_file_export_test.go
+++ b/internal/app/methods_file_export_test.go
@@ -5,6 +5,7 @@ import (
 	"bytes"
 	"context"
 	"encoding/json"
+	"io"
 	"os"
 	"strings"
 	"testing"
@@ -729,6 +730,60 @@ func BenchmarkExportQueryResultToFile_XLSX_StreamValues_20000Rows(b *testing.B)
 	}
 }
 
+func BenchmarkDumpTableSQL_SQLBackup_StreamMap_20000Rows(b *testing.B) {
+	rows, columns := benchmarkExportRows(20000)
+	streamDB := &fakeStreamExportDB{
+		streamCols: columns,
+		streamData: rows,
+	}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		writer := bufio.NewWriterSize(io.Discard, 1024*1024)
+		if err := dumpTableSQL(
+			writer,
+			streamDB,
+			connection.ConnectionConfig{Type: "mysql"},
+			"app",
+			"users",
+			false,
+			true,
+			map[string]string{},
+		); err != nil {
+			b.Fatalf("SQL 备份导出失败: %v", err)
+		}
+		if err := writer.Flush(); err != nil {
+			b.Fatalf("flush SQL 备份失败: %v", err)
+		}
+	}
+}
+
+func BenchmarkDumpTableSQL_SQLBackup_StreamValues_20000Rows(b *testing.B) {
+	rows, columns := benchmarkExportRowValues(20000)
+	streamDB := &fakeValueStreamExportDB{
+		streamCols:   columns,
+		streamValues: rows,
+	}
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		writer := bufio.NewWriterSize(io.Discard, 1024*1024)
+		if err := dumpTableSQL(
+			writer,
+			streamDB,
+			connection.ConnectionConfig{Type: "mysql"},
+			"app",
+			"users",
+			false,
+			true,
+			map[string]string{},
+		); err != nil {
+			b.Fatalf("SQL 备份导出失败: %v", err)
+		}
+		if err := writer.Flush(); err != nil {
+			b.Fatalf("flush SQL 备份失败: %v", err)
+		}
+	}
+}
+
 func TestFormatImportSQLValue_NormalizesTimestampWithoutTimezone(t *testing.T) {
 	got := formatImportSQLValue("postgres", "timestamp without time zone", "2026-01-21T18:32:26+08:00")
 	if got != "'2026-01-21 18:32:26'" {
@@ -808,6 +863,81 @@ func TestDumpTableSQL_PostgresBooleanBackupUsesBooleanLiterals(t *testing.T) {
 	}
 }
 
+func TestDumpTableSQL_MySQLBackupBatchesRowsIntoMultiValueInsert(t *testing.T) {
+	fake := &fakeValueStreamExportDB{
+		streamCols: []string{"id", "name"},
+		streamValues: [][]interface{}{
+			{1, "alice"},
+			{2, "bob"},
+			{3, "carol"},
+		},
+	}
+	var buf bytes.Buffer
+	writer := bufio.NewWriter(&buf)
+
+	err := dumpTableSQL(
+		writer,
+		fake,
+		connection.ConnectionConfig{Type: "mysql"},
+		"app",
+		"users",
+		false,
+		true,
+		map[string]string{},
+	)
+	if err != nil {
+		t.Fatalf("dumpTableSQL 返回错误: %v", err)
+	}
+	if err := writer.Flush(); err != nil {
+		t.Fatalf("flush 导出 SQL 失败: %v", err)
+	}
+
+	content := buf.String()
+	if strings.Count(content, "INSERT INTO `app`.`users`") != 1 {
+		t.Fatalf("MySQL 备份应合并为单条批量 INSERT，content=%s", content)
+	}
+	if !strings.Contains(content, "VALUES (1, 'alice'),\n(2, 'bob'),\n(3, 'carol');") {
+		t.Fatalf("MySQL 批量 INSERT 内容异常，content=%s", content)
+	}
+}
+
+func TestDumpTableSQL_OracleBackupBatchesRowsIntoInsertAll(t *testing.T) {
+	fake := &fakeValueStreamExportDB{
+		streamCols: []string{"id", "name"},
+		streamValues: [][]interface{}{
+			{1, "alice"},
+			{2, "bob"},
+		},
+	}
+	var buf bytes.Buffer
+	writer := bufio.NewWriter(&buf)
+
+	err := dumpTableSQL(
+		writer,
+		fake,
+		connection.ConnectionConfig{Type: "oracle"},
+		"APP",
+		"USERS",
+		false,
+		true,
+		map[string]string{},
+	)
+	if err != nil {
+		t.Fatalf("dumpTableSQL 返回错误: %v", err)
+	}
+	if err := writer.Flush(); err != nil {
+		t.Fatalf("flush 导出 SQL 失败: %v", err)
+	}
+
+	content := buf.String()
+	if strings.Count(content, "INSERT ALL") != 1 {
+		t.Fatalf("Oracle 备份应合并为单条 INSERT ALL，content=%s", content)
+	}
+	if !strings.Contains(content, "INTO \"APP\".\"USERS\" (\"id\", \"name\") VALUES (1, 'alice')\n  INTO \"APP\".\"USERS\" (\"id\", \"name\") VALUES (2, 'bob')\nSELECT 1 FROM DUAL;") {
+		t.Fatalf("Oracle INSERT ALL 内容异常，content=%s", content)
+	}
+}
+
 func TestFilterExportObjectsBySchema_PostgresQualifiedObjectsOnly(t *testing.T) {
 	got := filterExportObjectsBySchema(
 		connection.ConnectionConfig{Type: "postgres"},