25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
import { computed, ref, watch } from "vue";
import { defineStore } from "pinia";
import * as api from "@/lib/backend/api";
import { BackendErrorException, normalizeBackendError } from "@/lib/backend/errorUtils";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
import { tableDataCopyColumnOptions, type PasteTableMode } from "@/lib/table/tableClipboard";
import { uuid } from "@/lib/common/utils";
import { useConnectionStore } from "./connectionStore";
import { useQueryStore } from "./queryStore";
import { useProductionSafetyStore } from "./productionSafetyStore";
import type { ConnectionConfig } from "@/types/database";
import { useExportTracker, type ExportTask } from "@/composables/useExportTracker";
import { useToast } from "@/composables/useToast";
import i18n from "@/i18n";
export interface MysqlTableCopyEntry {
connection: ConnectionConfig;
database: string;
catalog?: string;
schema?: string;
sourceName: string;
targetName: string;
tableComment?: string | null;
identifierQuote?: string;
}
type CopyStatus = "running" | "cancelling" | "succeeded" | "failed" | "cancelled" | "unknown";
export interface TableCopyTask {
id: string;
status: CopyStatus;
phase: "preparing" | "structure" | "data" | "refreshing";
startedAt: number;
finishedAt?: number;
currentIndex: number;
targets: Array<{ name: string; status: "pending" | CopyStatus; structureCreated: boolean; copiedRows?: number; error?: string }>;
error?: string;
refreshError?: string;
cancelError?: string;
}
class CopyCancelled extends Error {}
class CopyOutcomeUnknown extends Error {}
const message = (error: unknown) => (error instanceof Error ? error.message : String(error));
async function observeExecution(id: string, cancel: boolean) {
let timer: ReturnType<typeof setTimeout> | undefined;
try {
return await Promise.race([
api.cancelConditionalUpdate(id, cancel ? undefined : { cancel: false }),
new Promise<never>((_, reject) => {
timer = setTimeout(() => reject(new Error("Execution status request timed out. The original copy result is still pending.")), 12_000);
}),
]);
} finally {
clearTimeout(timer);
}
}
/** One app-owned task shared by both clone/paste entry points, independent of their lifetime. */
export const useTableCopyTaskStore = defineStore("tableCopyTask", () => {
const task = ref<TableCopyTask>();
const viewedTask = ref<TableCopyTask>();
const displayedTask = computed(() => viewedTask.value ?? task.value);
const open = ref(false);
const executionId = ref<string>();
const cancelSending = ref(false);
const busy = computed(() => !!executionId.value || task.value?.status === "running" || task.value?.status === "cancelling" || (task.value?.phase === "refreshing" && !task.value.finishedAt));
let cancelRequested = false;
const tracker = useExportTracker();
let trackedTask: ExportTask | undefined;
function showDetails(record = task.value) {
if (!record) return;
viewedTask.value = record;
open.value = true;
}
function syncBackgroundTask() {
const current = task.value;
if (!current || trackedTask?.exportId !== current.id) return;
const status = current.status;
Object.assign(trackedTask, {
status: status === "unknown" ? (busy.value ? "Unknown" : "Error") : busy.value ? (status === "cancelling" ? "Cancelling" : "Running") : status === "succeeded" ? "Done" : status === "cancelled" ? "Cancelled" : "Error",
copyPhase: busy.value && status !== "unknown" ? (status === "cancelling" ? "cancelling" : current.phase) : status,
currentTable: current.targets[current.currentIndex]?.name,
affectedRows: current.targets.some((target) => target.copiedRows !== undefined) ? current.targets.reduce((sum, target) => sum + (target.copiedRows ?? 0), 0) : undefined,
errorMessage: [current.error, current.refreshError, current.cancelError].filter(Boolean).join("\n") || null,
startedAt: current.startedAt,
finishedAt: current.finishedAt,
canCancel: busy.value && current.phase !== "refreshing" && !cancelSending.value,
canRemove: !busy.value,
});
if (busy.value) tracker.registerTaskCancelHandler(current.id, cancel);
else tracker.unregisterTaskCancelHandler(current.id);
}
watch([task, busy, cancelSending], syncBackgroundTask, { deep: true, flush: "sync" });
function notify(record: TableCopyTask, started: boolean) {
const t = i18n.global.t;
useToast().toast(started ? t("tableCopyTask.backgroundStarted") : t("tableCopyTask.backgroundFinished", { status: t(`tableCopyTask.${record.status}`) }), 5000, { label: t("tableCopyTask.details"), onClick: () => showDetails(record) });
}
function checkCancelled() {
if (cancelRequested) throw new CopyCancelled();
}
async function cancel() {
if (!task.value || !busy.value || cancelSending.value) return;
if (task.value.phase === "refreshing") return; // The database outcome is already final.
cancelRequested = true;
if (task.value.status !== "unknown") task.value.status = "cancelling";
useProductionSafetyStore().cancelScope(task.value.id);
const id = executionId.value;
if (!id) return; // Planning and safety confirmation check again before dispatch.
cancelSending.value = true;
task.value.cancelError = undefined;
try {
// Registration can race a just-dispatched IPC/HTTP request. Never interpret
// a missing registration, or a cancellation request, as a completed copy.
for (let attempt = 0; attempt < 5 && executionId.value === id; attempt++) {
const result = await observeExecution(id, true);
if (result.requested || result.terminal) break;
await new Promise((resolve) => setTimeout(resolve, 100));
}
} catch (error) {
if (executionId.value === id) task.value.cancelError = message(error);
} finally {
cancelSending.value = false;
}
}
async function checkCompletion() {
const id = executionId.value;
if (!id || !task.value || cancelSending.value) return;
cancelSending.value = true;
try {
const result = await observeExecution(id, false);
// A lost response never becomes a success or permission to replay. Only
// release the running-task guard when the original DB execution ended.
if (executionId.value === id && task.value.status === "unknown" && result.databaseTerminal === true) {
executionId.value = undefined;
task.value.finishedAt = Date.now();
}
} catch (error) {
task.value.cancelError = message(error);
} finally {
cancelSending.value = false;
}
}
function close() {
open.value = false; // Only hides details; the app-owned task keeps running.
}
async function run(input: readonly MysqlTableCopyEntry[], mode: PasteTableMode): Promise<boolean> {
if (busy.value) {
showDetails();
return false;
}
if (!input.length) return false;
// Capture all identities before the first await. Do not retain credentials in UI state.
const entries = input.map((entry) => ({ ...entry, connection: { ...entry.connection }, targetName: entry.targetName.trim() }));
cancelRequested = false;
task.value = { id: uuid(), status: "running", phase: "preparing", startedAt: Date.now(), currentIndex: 0, targets: entries.map((entry) => ({ name: entry.targetName, status: "pending", structureCreated: false })) };
const current = task.value;
viewedTask.value = current;
open.value = false;
trackedTask = tracker.addTableCopyTask(current.id, current.targets.map((target) => target.name).join(", "), () => showDetails(current));
syncBackgroundTask();
notify(current, true);
const refresh = new Set<MysqlTableCopyEntry>();
async function execute(entry: MysqlTableCopyEntry, sql: string) {
checkCancelled();
const result = await executeWithProductionSqlGuard({
connection: entry.connection,
database: entry.database,
sql,
source: "Table copy",
scopeId: current.id,
execute: async () => {
checkCancelled();
const id = uuid();
executionId.value = id;
try {
// This existing command keeps the database execution owned until its
// response/rollback settles instead of racing the cancellation token.
const value = await api.executeConditionalUpdate(entry.connection.id, entry.database, sql, entry.schema, id, { timeoutSecs: 0, catalog: entry.catalog });
if (value.execution_error) throw value.error ? new BackendErrorException(value.error) : new Error("The database did not confirm the table copy.");
refresh.add(entry);
executionId.value = undefined;
return value;
} catch (error) {
const envelope = normalizeBackendError(error);
const rejected = envelope?.operationOutcome === "not_started" || (envelope?.diagnostics?.category === "sql" && envelope.diagnostics.stage === "execute");
if (!rejected) throw new CopyOutcomeUnknown(message(error));
// A failed data write may have partially changed a nontransactional
// target. A rejected CREATE, however, must not reload an existing,
// untouched target (which may have unsaved edits).
if (current.phase === "data") refresh.add(entry);
executionId.value = undefined;
if (cancelRequested && /cancel(?:led|ed)?|query execution was interrupted/i.test(envelope?.detail || message(error))) throw new CopyCancelled();
throw error;
}
},
});
if (result === undefined) throw new CopyCancelled(); // Read-only/production guard denied dispatch.
return result;
}
for (const [index, entry] of entries.entries()) {
const target = current.targets[index]!;
current.currentIndex = index;
current.phase = "preparing";
try {
checkCancelled();
target.status = "running";
await useConnectionStore().ensureConnected(entry.connection.id);
checkCancelled();
const { buildCopyTableDataSql, buildDuplicateTableStructurePlan } = await import("@/lib/database/dbAdminSql");
checkCancelled();
if (mode !== "data-only") {
const plan = await buildDuplicateTableStructurePlan({ ...entry, connectionId: entry.connection.id, databaseType: "mysql" });
checkCancelled();
current.phase = "structure";
await execute(entry, plan.sql);
target.structureCreated = true;
}
if (mode !== "structure-only") {
checkCancelled();
current.phase = "preparing";
const columns = await api.getColumns(entry.connection.id, entry.database, entry.schema || "", entry.sourceName, entry.catalog);
checkCancelled();
const options = tableDataCopyColumnOptions("mysql", columns);
if (!options.columns.length) throw new Error("No writable columns available for table data copy.");
const sql = await buildCopyTableDataSql({ ...entry, ...options, databaseType: "mysql", normalizeNewTargetName: mode === "structure-and-data" });
checkCancelled();
current.phase = "data";
const result = await execute(entry, sql);
target.copiedRows = result.affected_rows;
}
target.status = "succeeded"; // A late cancel cannot undo an acknowledged successful statement.
} catch (error) {
if (error instanceof CopyCancelled) {
target.status = "cancelled";
current.status = "cancelled";
break;
}
target.error = message(error);
current.error ??= target.error;
if (error instanceof CopyOutcomeUnknown) {
target.status = "unknown";
current.status = "unknown";
break;
}
target.status = "failed";
}
}
if (current.status === "running" || current.status === "cancelling") current.status = current.targets.some((target) => target.status === "failed") ? "failed" : "succeeded";
if (current.status !== "unknown") {
current.phase = "refreshing";
// Mutation outcome and refresh errors are independent: never suggest
// replaying a successful copy because refreshing an open tab failed.
for (const entry of refresh) {
const results = await Promise.allSettled([
useConnectionStore().refreshObjectListTreeNode(entry.connection.id, entry.database, entry.schema),
useQueryStore().refreshDataTabsForTable({ connectionId: entry.connection.id, database: entry.database, schema: entry.schema, catalog: entry.catalog, name: entry.targetName }),
]);
for (const result of results) if (result.status === "rejected") current.refreshError ??= message(result.reason);
}
current.finishedAt = Date.now();
}
if (!open.value || displayedTask.value !== current) notify(current, false);
return current.status === "succeeded";
}
return { task, displayedTask, open, busy, cancelSending, run, cancel, checkCompletion, close, showDetails };
});