From 0e33c73035d5d18c7952800fd19927d9ae1b7840 Mon Sep 17 00:00:00 2001
From: miracle <fagao@yikangsi.cn>
Date: Wed, 22 Jul 2026 16:56:49 +0800
Subject: [PATCH] perf(import): optimize large file imports

---
 Cargo.lock                                    |    1 +
 .../components/import/TableImportDialog.vue   |  191 +-
 apps/desktop/src/i18n/locales/en.ts           |    9 +
 apps/desktop/src/i18n/locales/es.ts           |    9 +
 apps/desktop/src/i18n/locales/it.ts           |    9 +
 apps/desktop/src/i18n/locales/ja.ts           |    9 +
 apps/desktop/src/i18n/locales/pt-BR.ts        |    9 +
 apps/desktop/src/i18n/locales/zh-CN.ts        |    9 +
 apps/desktop/src/i18n/locales/zh-TW.ts        |    9 +
 .../lib/__tests__/table/tableImport.spec.ts   |   37 +-
 apps/desktop/src/lib/backend/api.ts           |    2 +
 apps/desktop/src/lib/backend/http.ts          |   15 +-
 apps/desktop/src/lib/backend/tauri.ts         |   28 +-
 apps/desktop/src/lib/table/tableImport.ts     |   48 +
 crates/dbx-core/Cargo.toml                    |    1 +
 .../dbx-core/examples/table_import_bench.rs   |  211 +
 crates/dbx-core/src/connection.rs             |   78 +-
 crates/dbx-core/src/query.rs                  |   29 +-
 crates/dbx-core/src/table_import.rs           | 4454 +++++++++++++++--
 crates/dbx-core/src/task_supervisor.rs        |   57 +-
 crates/dbx-core/src/transfer.rs               |   72 +
 crates/dbx-web/src/main.rs                    |    3 +
 crates/dbx-web/src/routes/connection.rs       |    1 +
 crates/dbx-web/src/routes/mongo.rs            |    1 +
 crates/dbx-web/src/routes/table_import.rs     |  240 +-
 crates/dbx-web/src/sse.rs                     |   19 +
 crates/dbx-web/src/state.rs                   |    3 +-
 package.json                                  |    1 +
 src-tauri/src/commands/table_import.rs        |  102 +-
 29 files changed, 5032 insertions(+), 625 deletions(-)
 create mode 100644 crates/dbx-core/examples/table_import_bench.rs

diff --git a/Cargo.lock b/Cargo.lock
index 2a5907d019..f4c050630c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1914,6 +1914,7 @@ dependencies = [
  "sqlparser",
  "ssfmt",
  "sysinfo",
+ "tempfile",
  "tiberius",
  "tokio",
  "tokio-postgres",
diff --git a/apps/desktop/src/components/import/TableImportDialog.vue b/apps/desktop/src/components/import/TableImportDialog.vue
index 88b22e6200..f966a75e2b 100644
--- a/apps/desktop/src/components/import/TableImportDialog.vue
+++ b/apps/desktop/src/components/import/TableImportDialog.vue
@@ -13,7 +13,19 @@ import { AlertTriangle, ArrowLeft, ArrowRight, Check, CheckCircle2, FileJson, Fi
 import { useConnectionStore } from "@/stores/connectionStore";
 import { useSettingsStore } from "@/stores/settingsStore";
 import { useToast } from "@/composables/useToast";
-import { autoMapImportColumns, buildTableImportParseOptions, nextTableImportWizardStep, previousTableImportWizardStep, requiredImportTargetColumns, suggestImportTargetDataTypes, validateImportMappings, type TableImportWizardStep } from "@/lib/table/tableImport";
+import {
+  autoMapImportColumns,
+  buildTableImportParseOptions,
+  formatTableImportElapsed,
+  nextTableImportWizardStep,
+  previousTableImportWizardStep,
+  requiredImportTargetColumns,
+  resolveTableImportElapsed,
+  suggestImportTargetDataTypes,
+  tableImportProgressPercent,
+  validateImportMappings,
+  type TableImportWizardStep,
+} from "@/lib/table/tableImport";
 import { getDataTypeOptions } from "@/lib/table/tableStructureEditorState";
 import { tableStructureDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
 import type { ColumnInfo } from "@/types/database";
@@ -83,7 +95,10 @@ const emptyStringAsNull = ref(true);
 const selectedSheet = ref("");
 const jsonShape = ref<api.TableImportJsonShape>("auto");
 const previewLimit = ref(50);
+const liveElapsedMs = ref(0);
 let previewReloadTimer: ReturnType<typeof setTimeout> | null = null;
+let importElapsedTimer: ReturnType<typeof setInterval> | null = null;
+let importStartedAt = 0;
 let dataTypeOptionsRequestId = 0;
 let previewRequestId = 0;
 let batchEncodingRequestId = 0;
@@ -158,11 +173,9 @@ const canGoNext = computed(() => {
   if (wizardStep.value === "mapping") return mappingValidation.value.valid;
   return false;
 });
-const progressPercent = computed(() => {
-  const p = progress.value;
-  if (!p || p.totalRows <= 0) return 0;
-  return Math.min(100, Math.round((p.rowsImported / p.totalRows) * 100));
-});
+const rawProgressPercent = computed(() => tableImportProgressPercent(progress.value));
+const progressPercentFloor = ref(0);
+const progressPercent = computed(() => Math.max(rawProgressPercent.value, progressPercentFloor.value));
 const currentStepIndex = computed(() => wizardSteps.findIndex((step) => step.value === wizardStep.value));
 const targetLabel = computed(() => {
   const pieces = [selectedConnection.value?.name, props.prefillDatabase, props.prefillSchema, targetTableName.value].filter(Boolean);
@@ -181,9 +194,43 @@ const createColumnSummaries = computed(() =>
   })),
 );
 const parseOptions = computed<api.TableImportParseOptions>(() => taskParseOptions(sourceFormat.value, selectedSheet.value));
-const terminalStatus = computed(() => progress.value?.status && ["done", "error", "cancelled"].includes(progress.value.status));
+const terminalStatus = computed(() => !!progress.value?.status && ["done", "error", "cancelled"].includes(progress.value.status));
+const displayedElapsedMs = computed(() => resolveTableImportElapsed(liveElapsedMs.value, progress.value?.elapsedMs, terminalStatus.value));
+const progressLabelKey = computed(() => {
+  if (terminalStatus.value) return `tableImport.status_${progress.value?.status || "idle"}`;
+  return `tableImport.phase_${progress.value?.phase || "writing"}`;
+});
+
+function previewRowsLabel(currentPreview: api.TableImportPreview | null | undefined): string {
+  if (!currentPreview) return "-";
+  if (currentPreview.totalRowsExact !== false) return currentPreview.totalRows.toLocaleString();
+  return t("tableImport.previewPartial", { rows: currentPreview.rows.length });
+}
+
+function stopImportElapsedClock() {
+  if (importElapsedTimer) {
+    clearInterval(importElapsedTimer);
+    importElapsedTimer = null;
+  }
+}
+
+function refreshImportElapsedClock() {
+  if (importStartedAt > 0) {
+    liveElapsedMs.value = Math.max(0, Math.round(performance.now() - importStartedAt));
+  }
+}
+
+function startImportElapsedClock() {
+  stopImportElapsedClock();
+  importStartedAt = performance.now();
+  liveElapsedMs.value = 0;
+  importElapsedTimer = setInterval(refreshImportElapsedClock, 100);
+}
 
 function resetState() {
+  stopImportElapsedClock();
+  importStartedAt = 0;
+  liveElapsedMs.value = 0;
   previewRequestId++;
   batchEncodingRequestId++;
   if (previewReloadTimer) {
@@ -274,12 +321,23 @@ function taskParseOptions(format: api.TableImportSourceFormat, sheetName = ""):
 
 function importParseOptions(format: api.TableImportSourceFormat, currentPreview: api.TableImportPreview, sheetName = ""): api.TableImportParseOptions {
   const options = taskParseOptions(format, sheetName);
-  if (isDelimitedFormat(format) && options.encoding === "auto" && currentPreview.effectiveEncoding) {
+  if (isDelimitedFormat(format) && currentPreview.totalRowsExact !== false && options.encoding === "auto" && currentPreview.effectiveEncoding) {
     options.encoding = currentPreview.effectiveEncoding;
   }
   return options;
 }
 
+function preparedImportSource(currentPreview: api.TableImportPreview): api.TableImportPreparedSource {
+  return {
+    fingerprint: currentPreview.sourceFingerprint,
+    columns: currentPreview.columns,
+    rows: currentPreview.rows,
+    totalRows: currentPreview.totalRows,
+    totalRowsExact: currentPreview.totalRowsExact !== false,
+    effectiveEncoding: currentPreview.effectiveEncoding ?? null,
+  };
+}
+
 function mergeDataTypeOptions(...groups: readonly string[][]): string[] {
   const seen = new Set<string>();
   const result: string[] = [];
@@ -358,7 +416,9 @@ async function loadTargetColumns() {
 }
 
 async function previewSelectedImportFile(fileOrPath: string | File) {
-  return api.previewTableImportFile(fileOrPath, {
+  const reusablePreview = preview.value?.sourceRef ? preview.value : null;
+  return api.previewTableImportFile(reusablePreview?.filePath || fileOrPath, {
+    sourceRef: reusablePreview?.sourceRef || null,
     sourceFormat: sourceFormat.value,
     parseOptions: parseOptions.value,
     previewLimit: Math.max(1, Number(previewLimit.value) || 50),
@@ -445,20 +505,22 @@ async function prepareBatchSources(sources: ImportSource[]) {
       });
       const sheets = format === "excel" && initialPreview.sheets?.length ? initialPreview.sheets : [""];
       for (const sheetName of sheets) {
-        const taskPreview =
-          sheetName && sheetName !== initialPreview.sheets?.[0]
-            ? await api.previewTableImportFile(source, {
-                sourceFormat: format,
-                parseOptions: taskParseOptions(format, sheetName),
-                previewLimit: Math.max(1, Number(previewLimit.value) || 50),
-              })
-            : initialPreview;
+        const reusableSource = initialPreview.sourceRef ? initialPreview.filePath : source;
+        const effectiveSheetName = sheetName && sheetName === initialPreview.sheets?.[0] ? "" : sheetName;
+        const taskPreview = effectiveSheetName
+          ? await api.previewTableImportFile(reusableSource, {
+              sourceRef: initialPreview.sourceRef || null,
+              sourceFormat: format,
+              parseOptions: taskParseOptions(format, effectiveSheetName),
+              previewLimit: Math.max(1, Number(previewLimit.value) || 50),
+            })
+          : initialPreview;
         const tableBase = sheetName ? `${suggestedTableName(sourceName(source))}_${sheetName}` : sourceName(source);
         tasks.push({
           id: uuid(),
           source,
           format,
-          sheetName,
+          sheetName: effectiveSheetName,
           tableName: uniqueTableName(tableBase, usedNames),
           preview: taskPreview,
           columnMapping: Object.fromEntries(taskPreview.columns.map((column) => [column, column])),
@@ -591,15 +653,22 @@ async function startImport() {
   const tableName = targetTableName.value;
   if (!canImport.value || !currentPreview || !props.prefillConnectionId || !tableName) return;
   running.value = true;
+  progressPercentFloor.value = 0;
   cancelling.value = false;
   errorMessage.value = "";
   wizardStep.value = "execution";
   importId.value = uuid();
+  startImportElapsedClock();
   progress.value = {
     importId: importId.value,
     status: "running",
+    phase: "preparing",
     rowsImported: 0,
     totalRows: currentPreview.totalRows,
+    totalRowsExact: currentPreview.totalRowsExact !== false,
+    bytesRead: 0,
+    totalBytes: currentPreview.sizeBytes,
+    elapsedMs: 0,
   };
 
   try {
@@ -620,12 +689,13 @@ async function startImport() {
         createTable: targetMode.value === "create",
         batchSize: Math.max(1, Number(batchSize.value) || 500),
         dateTimeFormat: settingsStore.editorSettings.globalDateTimeImportFormat || undefined,
+        preparedSource: preparedImportSource(currentPreview),
       },
       (nextProgress) => {
-        progress.value = nextProgress;
+        progress.value = { ...nextProgress, elapsedMs: nextProgress.elapsedMs ?? liveElapsedMs.value };
       },
     );
-    progress.value = { importId: summary.importId, status: "done", rowsImported: summary.rowsImported, totalRows: summary.totalRows };
+    progress.value = { importId: summary.importId, status: "done", rowsImported: summary.rowsImported, totalRows: summary.totalRows, elapsedMs: summary.elapsedMs };
     toast(t("tableImport.success", { count: summary.rowsImported }), 2500);
     store.invalidateMetadataCache(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined, tableName);
     if (targetMode.value === "create") {
@@ -641,9 +711,12 @@ async function startImport() {
       status: progress.value?.status === "cancelled" ? "cancelled" : "error",
       rowsImported: progress.value?.rowsImported ?? 0,
       totalRows: progress.value?.totalRows ?? currentPreview.totalRows,
+      elapsedMs: progress.value?.elapsedMs ?? liveElapsedMs.value,
       error: message,
     };
   } finally {
+    refreshImportElapsedClock();
+    stopImportElapsedClock();
     running.value = false;
     cancelling.value = false;
   }
@@ -652,13 +725,18 @@ async function startImport() {
 async function startBatchImport() {
   if (!props.prefillConnectionId || !batchTasks.value.length || running.value) return;
   running.value = true;
+  progressPercentFloor.value = 0;
   cancelling.value = false;
   errorMessage.value = "";
   wizardStep.value = "execution";
-  const totalRows = batchTasks.value.reduce((sum, task) => sum + task.preview.totalRows, 0);
+  const totalRowsExact = batchTasks.value.every((task) => task.preview.totalRowsExact !== false);
+  const totalRows = totalRowsExact ? batchTasks.value.reduce((sum, task) => sum + task.preview.totalRows, 0) : 0;
+  const totalBytes = batchTasks.value.reduce((sum, task) => sum + task.preview.sizeBytes, 0);
   let completedRows = 0;
+  let completedBytes = 0;
   importId.value = uuid();
-  progress.value = { importId: importId.value, status: "running", rowsImported: 0, totalRows };
+  startImportElapsedClock();
+  progress.value = { importId: importId.value, status: "running", phase: "preparing", rowsImported: 0, totalRows, totalRowsExact, bytesRead: 0, totalBytes, elapsedMs: 0 };
 
   try {
     const tableNames = batchTasks.value.map((task) => task.tableName.trim().toLowerCase());
@@ -696,18 +774,35 @@ async function startBatchImport() {
           createTable: true,
           batchSize: Math.max(1, Number(batchSize.value) || 500),
           dateTimeFormat: settingsStore.editorSettings.globalDateTimeImportFormat || undefined,
+          preparedSource: preparedImportSource(task.preview),
+          retainSource: true,
         },
         (nextProgress) => {
           task.rowsImported = nextProgress.rowsImported;
-          progress.value = { ...nextProgress, rowsImported: completedRows + nextProgress.rowsImported, totalRows };
+          const hasRemainingTasks = index < batchTasks.value.length - 1;
+          const aggregateStatus = nextProgress.status === "done" && hasRemainingTasks ? "running" : nextProgress.status;
+          const aggregatePhase = nextProgress.status === "done" && hasRemainingTasks ? "preparing" : nextProgress.phase;
+          progress.value = {
+            ...nextProgress,
+            status: aggregateStatus,
+            phase: aggregatePhase,
+            rowsImported: completedRows + nextProgress.rowsImported,
+            totalRows,
+            totalRowsExact,
+            bytesRead: completedBytes + (nextProgress.bytesRead ?? 0),
+            totalBytes,
+            elapsedMs: liveElapsedMs.value,
+          };
         },
       );
       task.status = "done";
       task.rowsImported = summary.rowsImported;
       completedRows += summary.rowsImported;
+      completedBytes += task.preview.sizeBytes;
       store.invalidateMetadataCache(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined, task.tableName);
     }
-    progress.value = { importId: importId.value, status: "done", rowsImported: completedRows, totalRows };
+    refreshImportElapsedClock();
+    progress.value = { importId: importId.value, status: "done", phase: "done", rowsImported: completedRows, totalRows: completedRows, totalRowsExact: true, bytesRead: totalBytes, totalBytes, elapsedMs: liveElapsedMs.value };
     toast(t("tableImport.success", { count: completedRows }), 2500);
     store.refreshObjectListTreeNode(props.prefillConnectionId, props.prefillDatabase || "", props.prefillSchema || undefined).catch((error) => {
       console.warn("[DBX][table-import:refresh-created-table-failed]", error);
@@ -725,14 +820,27 @@ async function startBatchImport() {
       status: progress.value?.status === "cancelled" ? "cancelled" : "error",
       rowsImported: progress.value?.rowsImported ?? completedRows,
       totalRows,
+      elapsedMs: progress.value?.elapsedMs ?? liveElapsedMs.value,
       error: message,
     };
   } finally {
+    refreshImportElapsedClock();
+    stopImportElapsedClock();
+    await releaseTableImportSources();
     running.value = false;
     cancelling.value = false;
   }
 }
 
+async function releaseTableImportSources() {
+  const sourceRefs = new Set<string>();
+  if (preview.value?.sourceRef) sourceRefs.add(preview.value.sourceRef);
+  for (const task of batchTasks.value) {
+    if (task.preview.sourceRef) sourceRefs.add(task.preview.sourceRef);
+  }
+  await Promise.allSettled([...sourceRefs].map((sourceRef) => api.releaseTableImportSource(sourceRef)));
+}
+
 async function cancelImport() {
   if (!importId.value) return;
   cancelling.value = true;
@@ -769,7 +877,9 @@ async function reloadBatchPreviewsForEncoding() {
   try {
     for (const task of batchTasks.value) {
       if (!isDelimitedFormat(task.format)) continue;
-      const nextPreview = await api.previewTableImportFile(task.source, {
+      const reusableSource = task.preview.sourceRef ? task.preview.filePath : task.source;
+      const nextPreview = await api.previewTableImportFile(reusableSource, {
+        sourceRef: task.preview.sourceRef || null,
         sourceFormat: task.format,
         parseOptions: taskParseOptions(task.format, task.sheetName),
         previewLimit: Math.max(1, Number(previewLimit.value) || 50),
@@ -797,6 +907,8 @@ watch(
       resetState();
       void loadTargetColumns();
       void loadDataTypeOptions();
+    } else if (!running.value) {
+      void releaseTableImportSources();
     }
   },
   { immediate: true },
@@ -818,6 +930,14 @@ watch(targetMode, (mode) => {
     void loadDataTypeOptions();
   }
 });
+
+watch(rawProgressPercent, (percent) => {
+  if (progress.value?.status === "running") {
+    progressPercentFloor.value = Math.max(progressPercentFloor.value, percent);
+  } else if (progress.value?.status === "done") {
+    progressPercentFloor.value = 100;
+  }
+});
 </script>
 
 <template>
@@ -1056,7 +1176,9 @@ watch(targetMode, (mode) => {
               <RefreshCw v-else class="mr-1.5 h-3.5 w-3.5" />
               {{ preview ? t("tableImport.reloadPreview") : t("tableImport.loadPreview") }}
             </Button>
-            <span v-if="preview" class="text-xs text-muted-foreground">{{ t("tableImport.previewReady", { rows: preview.totalRows, columns: preview.columns.length }) }}</span>
+            <span v-if="preview" class="text-xs text-muted-foreground">
+              {{ preview.totalRowsExact !== false ? t("tableImport.previewReady", { rows: preview.totalRows, columns: preview.columns.length }) : t("tableImport.previewReadyPartial", { rows: preview.rows.length, columns: preview.columns.length }) }}
+            </span>
           </div>
         </div>
 
@@ -1068,7 +1190,7 @@ watch(targetMode, (mode) => {
             </div>
             <div class="rounded-md border px-3 py-2">
               <div class="text-muted-foreground">{{ t("tableImport.rows") }}</div>
-              <div class="font-medium">{{ preview.totalRows.toLocaleString() }}</div>
+              <div class="font-medium">{{ previewRowsLabel(preview) }}</div>
             </div>
             <div class="rounded-md border px-3 py-2">
               <div class="text-muted-foreground">{{ t("tableImport.mapped") }}</div>
@@ -1165,7 +1287,7 @@ watch(targetMode, (mode) => {
             </div>
             <div class="rounded-md border px-3 py-2">
               <div class="text-muted-foreground">{{ t("tableImport.rows") }}</div>
-              <div class="font-medium">{{ preview?.totalRows.toLocaleString() }}</div>
+              <div class="font-medium">{{ previewRowsLabel(preview) }}</div>
             </div>
             <div class="rounded-md border px-3 py-2">
               <div class="text-muted-foreground">{{ t("tableImport.mapped") }}</div>
@@ -1226,14 +1348,19 @@ watch(targetMode, (mode) => {
         <div v-else class="space-y-4">
           <div class="rounded-md border px-4 py-5">
             <div class="flex items-center gap-3">
-              <Loader2 v-if="running && !cancelling" class="h-5 w-5 animate-spin text-primary" />
-              <Square v-else-if="cancelling || progress?.status === 'cancelled'" class="h-5 w-5 fill-current text-destructive" />
+              <Square v-if="cancelling || progress?.status === 'cancelled'" class="h-5 w-5 fill-current text-destructive" />
               <CheckCircle2 v-else-if="progress?.status === 'done'" class="h-5 w-5 text-emerald-600" />
               <AlertTriangle v-else-if="progress?.status === 'error'" class="h-5 w-5 text-destructive" />
+              <Loader2 v-else-if="running" class="h-5 w-5 animate-spin text-primary" />
               <FileUp v-else class="h-5 w-5 text-muted-foreground" />
               <div class="min-w-0 flex-1">
-                <div class="text-sm font-medium">{{ t(`tableImport.status_${progress?.status || "idle"}`) }}</div>
-                <div class="mt-1 text-xs text-muted-foreground">{{ progress?.rowsImported ?? 0 }} / {{ progress?.totalRows ?? preview?.totalRows ?? 0 }} · {{ progressPercent }}%</div>
+                <div class="text-sm font-medium">{{ t(progressLabelKey) }}</div>
+                <div class="mt-1 text-xs text-muted-foreground">
+                  <template v-if="progress?.totalRowsExact !== false && (progress?.totalRows ?? 0) > 0">{{ progress?.rowsImported ?? 0 }} / {{ progress?.totalRows ?? 0 }}</template>
+                  <template v-else>{{ progress?.rowsImported ?? 0 }} {{ t("tableImport.rowsImported") }}</template>
+                  · {{ progressPercent }}% ·
+                  {{ t("tableImport.elapsed", { duration: formatTableImportElapsed(displayedElapsedMs) }) }}
+                </div>
               </div>
             </div>
             <div class="mt-4 h-2 overflow-hidden rounded bg-muted">
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index ddb280bd15..3e7092bff1 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -3054,6 +3054,9 @@ export default {
     loadPreview: "Load Preview",
     reloadPreview: "Reload Preview",
     previewReady: "{rows} rows, {columns} columns",
+    previewReadyPartial: "Previewed {rows} rows, {columns} columns; total will be confirmed during import",
+    previewPartial: "Previewed {rows} rows",
+    rowsImported: "rows imported",
     file: "File",
     rows: "Rows",
     mapped: "Mapped",
@@ -3070,12 +3073,18 @@ export default {
     progress: "Progress",
     start: "Start Import",
     success: "Imported {count} rows",
+    elapsed: "Elapsed {duration}",
     back: "Back",
     next: "Next",
     truncateWarning: "Existing rows in the target table will be removed before import starts.",
     requiredUnmapped: "Required target columns are not mapped: {columns}",
     status_idle: "Ready to import",
     status_running: "Importing data",
+    phase_preparing: "Preparing import",
+    phase_detectingEncoding: "Detecting text encoding",
+    phase_reading: "Reading source file",
+    phase_writing: "Writing data",
+    phase_finalizing: "Finalizing import",
     status_done: "Import complete",
     status_error: "Import failed",
     status_cancelled: "Import cancelled",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index b4186a4e71..83d59872d0 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -2857,6 +2857,9 @@ export default withEnglishFallback({
     loadPreview: "Load Preview",
     reloadPreview: "Reload Preview",
     previewReady: "{rows} rows, {columns} columns",
+    previewReadyPartial: "Previewed {rows} rows, {columns} columns; total will be confirmed during import",
+    previewPartial: "Previewed {rows} rows",
+    rowsImported: "rows imported",
     file: "Archivo",
     rows: "Filas",
     mapped: "Mapeadas",
@@ -2873,12 +2876,18 @@ export default withEnglishFallback({
     progress: "Progreso",
     start: "Iniciar importación",
     success: "Se importaron {count} filas",
+    elapsed: "Duración: {duration}",
     back: "Back",
     next: "Next",
     truncateWarning: "Existing rows in the target table will be removed before import starts.",
     requiredUnmapped: "Required target columns are not mapped: {columns}",
     status_idle: "Ready to import",
     status_running: "Importing data",
+    phase_preparing: "Preparing import",
+    phase_detectingEncoding: "Detecting text encoding",
+    phase_reading: "Reading source file",
+    phase_writing: "Writing data",
+    phase_finalizing: "Finalizing import",
     status_done: "Import complete",
     status_error: "Import failed",
     status_cancelled: "Import cancelled",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 22ff362452..f8d9161fa1 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -2855,6 +2855,9 @@ export default withEnglishFallback({
     loadPreview: "Load Preview",
     reloadPreview: "Reload Preview",
     previewReady: "{rows} rows, {columns} columns",
+    previewReadyPartial: "Previewed {rows} rows, {columns} columns; total will be confirmed during import",
+    previewPartial: "Previewed {rows} rows",
+    rowsImported: "rows imported",
     file: "File",
     rows: "Righe",
     mapped: "Mappata",
@@ -2871,12 +2874,18 @@ export default withEnglishFallback({
     progress: "Progresso",
     start: "Avvia Importazione",
     success: "Importate {count} righe",
+    elapsed: "Durata: {duration}",
     back: "Back",
     next: "Next",
     truncateWarning: "Existing rows in the target table will be removed before import starts.",
     requiredUnmapped: "Required target columns are not mapped: {columns}",
     status_idle: "Ready to import",
     status_running: "Importing data",
+    phase_preparing: "Preparing import",
+    phase_detectingEncoding: "Detecting text encoding",
+    phase_reading: "Reading source file",
+    phase_writing: "Writing data",
+    phase_finalizing: "Finalizing import",
     status_done: "Import complete",
     status_error: "Import failed",
     status_cancelled: "Import cancelled",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 4bf6049602..9f013ece00 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -2856,6 +2856,9 @@ export default withEnglishFallback({
     loadPreview: "Load Preview",
     reloadPreview: "Reload Preview",
     previewReady: "{rows} rows, {columns} columns",
+    previewReadyPartial: "Previewed {rows} rows, {columns} columns; total will be confirmed during import",
+    previewPartial: "Previewed {rows} rows",
+    rowsImported: "rows imported",
     file: "ファイル",
     rows: "行数",
     mapped: "マッピング済み",
@@ -2872,12 +2875,18 @@ export default withEnglishFallback({
     progress: "進捗",
     start: "インポート開始",
     success: "{count}行をインポートしました",
+    elapsed: "経過時間 {duration}",
     back: "Back",
     next: "Next",
     truncateWarning: "Existing rows in the target table will be removed before import starts.",
     requiredUnmapped: "Required target columns are not mapped: {columns}",
     status_idle: "Ready to import",
     status_running: "Importing data",
+    phase_preparing: "Preparing import",
+    phase_detectingEncoding: "Detecting text encoding",
+    phase_reading: "Reading source file",
+    phase_writing: "Writing data",
+    phase_finalizing: "Finalizing import",
     status_done: "Import complete",
     status_error: "Import failed",
     status_cancelled: "Import cancelled",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 4739a4e8a1..190c7b4ffd 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -2857,6 +2857,9 @@ export default withEnglishFallback({
     loadPreview: "Load Preview",
     reloadPreview: "Reload Preview",
     previewReady: "{rows} rows, {columns} columns",
+    previewReadyPartial: "Previewed {rows} rows, {columns} columns; total will be confirmed during import",
+    previewPartial: "Previewed {rows} rows",
+    rowsImported: "rows imported",
     file: "Arquivo",
     rows: "Linhas",
     mapped: "Mapeado",
@@ -2873,12 +2876,18 @@ export default withEnglishFallback({
     progress: "Progresso",
     start: "Iniciar importação",
     success: "{count} linhas importadas",
+    elapsed: "Tempo decorrido: {duration}",
     back: "Back",
     next: "Next",
     truncateWarning: "Existing rows in the target table will be removed before import starts.",
     requiredUnmapped: "Required target columns are not mapped: {columns}",
     status_idle: "Ready to import",
     status_running: "Importing data",
+    phase_preparing: "Preparing import",
+    phase_detectingEncoding: "Detecting text encoding",
+    phase_reading: "Reading source file",
+    phase_writing: "Writing data",
+    phase_finalizing: "Finalizing import",
     status_done: "Import complete",
     status_error: "Import failed",
     status_cancelled: "Import cancelled",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index c7e900a404..008e3dd068 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -3044,6 +3044,9 @@ export default withEnglishFallback({
     loadPreview: "加载预览",
     reloadPreview: "重新加载预览",
     previewReady: "{rows} 行，{columns} 列",
+    previewReadyPartial: "已预览 {rows} 行、{columns} 列，总行数将在导入时确认",
+    previewPartial: "已预览 {rows} 行",
+    rowsImported: "行已导入",
     file: "文件",
     rows: "行数",
     mapped: "已映射",
@@ -3060,12 +3063,18 @@ export default withEnglishFallback({
     progress: "进度",
     start: "开始导入",
     success: "已导入 {count} 行",
+    elapsed: "耗时 {duration}",
     back: "上一步",
     next: "下一步",
     truncateWarning: "导入开始前会先删除目标表中的现有数据。",
     requiredUnmapped: "以下必填目标列未映射：{columns}",
     status_idle: "准备导入",
     status_running: "正在导入数据",
+    phase_preparing: "正在准备导入",
+    phase_detectingEncoding: "正在检测文本编码",
+    phase_reading: "正在读取源文件",
+    phase_writing: "正在写入数据",
+    phase_finalizing: "正在完成导入",
     status_done: "导入完成",
     status_error: "导入失败",
     status_cancelled: "导入已取消",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 26dd0e20cb..c47d4833bf 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -2674,6 +2674,9 @@ export default withEnglishFallback({
     loadPreview: "載入預覽",
     reloadPreview: "重新載入預覽",
     previewReady: "{rows} 列，{columns} 欄",
+    previewReadyPartial: "已預覽 {rows} 列、{columns} 欄，總列數將在匯入時確認",
+    previewPartial: "已預覽 {rows} 列",
+    rowsImported: "列已匯入",
     file: "檔案",
     rows: "列數",
     mapped: "已映射",
@@ -2690,12 +2693,18 @@ export default withEnglishFallback({
     progress: "進度",
     start: "開始匯入",
     success: "已匯入 {count} 行",
+    elapsed: "耗時 {duration}",
     back: "上一步",
     next: "下一步",
     truncateWarning: "匯入開始前會先刪除目標資料表中的現有資料。",
     requiredUnmapped: "以下必填目標欄位未映射：{columns}",
     status_idle: "準備匯入",
     status_running: "正在匯入資料",
+    phase_preparing: "正在準備匯入",
+    phase_detectingEncoding: "正在偵測文字編碼",
+    phase_reading: "正在讀取來源檔案",
+    phase_writing: "正在寫入資料",
+    phase_finalizing: "正在完成匯入",
     status_done: "匯入完成",
     status_error: "匯入失敗",
     status_cancelled: "匯入已取消",
diff --git a/apps/desktop/src/lib/__tests__/table/tableImport.spec.ts b/apps/desktop/src/lib/__tests__/table/tableImport.spec.ts
index 48544b05b5..1d64a95d8e 100644
--- a/apps/desktop/src/lib/__tests__/table/tableImport.spec.ts
+++ b/apps/desktop/src/lib/__tests__/table/tableImport.spec.ts
@@ -1,7 +1,42 @@
 import { describe, expect, it } from "vitest";
-import { autoMapImportColumns, buildTableImportParseOptions, nextTableImportWizardStep, previousTableImportWizardStep, requiredImportTargetColumns, suggestImportTargetDataTypes, validateImportMappings } from "@/lib/table/tableImport";
+import {
+  autoMapImportColumns,
+  buildTableImportParseOptions,
+  formatTableImportElapsed,
+  nextTableImportWizardStep,
+  previousTableImportWizardStep,
+  requiredImportTargetColumns,
+  resolveTableImportElapsed,
+  suggestImportTargetDataTypes,
+  tableImportProgressPercent,
+  validateImportMappings,
+} from "@/lib/table/tableImport";
 
 describe("tableImport", () => {
+  it("formats import elapsed time for progress and terminal summaries", () => {
+    expect(formatTableImportElapsed(0)).toBe("0 ms");
+    expect(formatTableImportElapsed(999)).toBe("999 ms");
+    expect(formatTableImportElapsed(1_250)).toBe("1.3 s");
+    expect(formatTableImportElapsed(61_000)).toBe("1m 1s");
+  });
+
+  it("uses the backend elapsed time as the terminal source of truth", () => {
+    expect(resolveTableImportElapsed(1_500, 1_000, false)).toBe(1_500);
+    expect(resolveTableImportElapsed(1_500, 2_000, false)).toBe(2_000);
+    expect(resolveTableImportElapsed(2_500, 2_000, true)).toBe(2_000);
+    expect(resolveTableImportElapsed(2_500, undefined, true)).toBe(2_500);
+  });
+
+  it("uses byte progress for unknown totals and reserves 100 for done", () => {
+    expect(tableImportProgressPercent({ status: "running", rowsImported: 500, totalRows: 0, totalRowsExact: false, bytesRead: 50, totalBytes: 100 })).toBe(50);
+    expect(tableImportProgressPercent({ status: "running", rowsImported: 1000, totalRows: 0, totalRowsExact: false, bytesRead: 100, totalBytes: 100 })).toBe(99);
+    expect(tableImportProgressPercent({ status: "done", rowsImported: 1000, totalRows: 1000, totalRowsExact: true })).toBe(100);
+    expect(tableImportProgressPercent({ status: "running", phase: "detectingEncoding", rowsImported: 0, totalRows: 1000, totalRowsExact: true, bytesRead: 100, totalBytes: 100 })).toBe(10);
+    expect(tableImportProgressPercent({ status: "running", phase: "reading", rowsImported: 0, totalRows: 0, totalRowsExact: false, bytesRead: 0, totalBytes: 100 })).toBe(0);
+    expect(tableImportProgressPercent({ status: "running", phase: "writing", rowsImported: 500, totalRows: 1000, totalRowsExact: true, bytesRead: 50, totalBytes: 100 })).toBe(55);
+    expect(tableImportProgressPercent({ status: "running", phase: "finalizing", rowsImported: 1000, totalRows: 1000, totalRowsExact: true, bytesRead: 100, totalBytes: 100 })).toBe(99);
+  });
+
   it("auto maps exact and normalized column names", () => {
     expect(autoMapImportColumns(["id", "user name", "ignored"], ["id", "user_name"])).toEqual({
       id: "id",
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.ts
index f5f0831f27..84c4e407a4 100644
--- a/apps/desktop/src/lib/backend/api.ts
+++ b/apps/desktop/src/lib/backend/api.ts
@@ -338,6 +338,7 @@ export const sortTablesByFkDependency = forward("sortTablesByFkDependency");
 export const previewTableImportFile = forward("previewTableImportFile");
 export const importTableFile = forward("importTableFile");
 export const cancelTableImport = forward("cancelTableImport");
+export const releaseTableImportSource = forward("releaseTableImportSource");
 
 // Database Export
 export const beginDatabaseBackupSnapshot = forward("beginDatabaseBackupSnapshot");
@@ -614,6 +615,7 @@ export type {
   TableImportParseOptions,
   TableImportPreviewRequest,
   TableImportPreview,
+  TableImportPreparedSource,
   TableImportRequest,
   TableImportSummary,
   TableImportProgress,
diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.ts
index f9d3294129..170f91b3f1 100644
--- a/apps/desktop/src/lib/backend/http.ts
+++ b/apps/desktop/src/lib/backend/http.ts
@@ -1569,10 +1569,15 @@ export async function previewTableImportFile(fileOrPath: string | File | TableIm
     if (!options.sourceRef) {
       throw new Error("previewTableImportFile in web mode requires a File object for new uploads");
     }
-    const res = await fetch(apiUrl("/api/import/preview"), {
+    const res = await fetch(apiUrl("/api/import/preview-source"), {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ request: { ...options, filePath: fileOrPath } }),
+      body: JSON.stringify({
+        sourceRef: options.sourceRef,
+        sourceFormat: options.sourceFormat,
+        parseOptions: options.parseOptions,
+        previewLimit: options.previewLimit,
+      }),
     });
     if (!res.ok) throw new Error(await res.text());
     return res.json();
@@ -1608,6 +1613,7 @@ export async function importTableFile(request: TableImportRequest, onProgress: (
           importId: progress.importId,
           rowsImported: progress.rowsImported,
           totalRows: progress.totalRows,
+          elapsedMs: progress.elapsedMs,
         };
         es.close();
         resolve(summary);
@@ -1627,6 +1633,11 @@ export async function cancelTableImport(importId: string): Promise<boolean> {
   return post("/api/import/cancel", { importId });
 }
 
+export async function releaseTableImportSource(sourceRef: string): Promise<boolean> {
+  const result = await post<{ released: boolean }>("/api/import/source/release", { sourceRef });
+  return result.released;
+}
+
 // ---------------------------------------------------------------------------
 // Database Export
 // ---------------------------------------------------------------------------
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index 04d32e23ca..ded6aa37d1 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -2287,6 +2287,7 @@ export async function sortTablesByFkDependency(options: SortTablesByFkOptions):
 // --- Table File Import ---
 export type TableImportMode = "append" | "truncate";
 export type TableImportStatus = "running" | "done" | "error" | "cancelled";
+export type TableImportPhase = "preparing" | "detectingEncoding" | "reading" | "writing" | "finalizing" | "done";
 export type TableImportSourceFormat = "csv" | "tsv" | "delimited" | "json" | "excel";
 export type TableImportJsonShape = "auto" | "objects" | "arrays";
 export type TableImportTextEncoding = "auto" | "utf8" | "gbk" | "utf16Le" | "utf16Be";
@@ -2328,10 +2329,21 @@ export interface TableImportPreview {
   columns: string[];
   rows: unknown[][];
   totalRows: number;
+  totalRowsExact?: boolean;
+  sourceFingerprint: string;
   effectiveEncoding?: TableImportTextEncoding | null;
   sheets?: string[];
 }
 
+export interface TableImportPreparedSource {
+  fingerprint: string;
+  columns: string[];
+  rows: unknown[][];
+  totalRows: number;
+  totalRowsExact?: boolean;
+  effectiveEncoding?: TableImportTextEncoding | null;
+}
+
 export interface TableImportRequest {
   importId: string;
   connectionId: string;
@@ -2347,19 +2359,27 @@ export interface TableImportRequest {
   createTable?: boolean;
   batchSize: number;
   dateTimeFormat?: string;
+  preparedSource?: TableImportPreparedSource | null;
+  retainSource?: boolean;
 }
 
 export interface TableImportSummary {
   importId: string;
   rowsImported: number;
   totalRows: number;
+  elapsedMs: number;
 }
 
 export interface TableImportProgress {
   importId: string;
   status: TableImportStatus;
+  phase?: TableImportPhase;
   rowsImported: number;
   totalRows: number;
+  totalRowsExact?: boolean;
+  bytesRead?: number;
+  totalBytes?: number;
+  elapsedMs: number;
   error?: string | null;
 }
 
@@ -2381,7 +2401,9 @@ export async function importTableFile(request: TableImportRequest, onProgress: (
     }
   });
   try {
-    return await invoke("import_table_file", { request });
+    const summary = await invoke<TableImportSummary>("import_table_file", { request });
+    unlisten();
+    return summary;
   } catch (e) {
     unlisten();
     throw e;
@@ -2392,6 +2414,10 @@ export async function cancelTableImport(importId: string): Promise<boolean> {
   return invoke("cancel_table_import", { importId });
 }
 
+export async function releaseTableImportSource(_sourceRef: string): Promise<boolean> {
+  return false;
+}
+
 // --- Database Export ---
 export interface DatabaseExportRequest {
   exportId: string;
diff --git a/apps/desktop/src/lib/table/tableImport.ts b/apps/desktop/src/lib/table/tableImport.ts
index f9aebba35c..7c70b0e988 100644
--- a/apps/desktop/src/lib/table/tableImport.ts
+++ b/apps/desktop/src/lib/table/tableImport.ts
@@ -23,10 +23,58 @@ export interface ImportTargetColumnLike {
   is_primary_key?: boolean;
 }
 
+export interface TableImportProgressLike {
+  status: "running" | "done" | "error" | "cancelled";
+  phase?: "preparing" | "detectingEncoding" | "reading" | "writing" | "finalizing" | "done";
+  rowsImported: number;
+  totalRows: number;
+  totalRowsExact?: boolean;
+  bytesRead?: number;
+  totalBytes?: number;
+}
+
 export type TableImportWizardStep = "source" | "options" | "mapping" | "review" | "execution";
 
 export const TABLE_IMPORT_WIZARD_STEPS: TableImportWizardStep[] = ["source", "options", "mapping", "review", "execution"];
 
+export function formatTableImportElapsed(ms: number): string {
+  const elapsedMs = Math.max(0, Number.isFinite(ms) ? Math.round(ms) : 0);
+  if (elapsedMs < 1000) return `${elapsedMs} ms`;
+  const seconds = elapsedMs / 1000;
+  if (seconds < 60) return `${seconds.toFixed(1)} s`;
+  const minutes = Math.floor(seconds / 60);
+  return `${minutes}m ${Math.round(seconds % 60)}s`;
+}
+
+export function resolveTableImportElapsed(liveElapsedMs: number, backendElapsedMs: number | undefined, terminal: boolean): number {
+  const live = Math.max(0, Number.isFinite(liveElapsedMs) ? liveElapsedMs : 0);
+  const backend = backendElapsedMs === undefined || !Number.isFinite(backendElapsedMs) ? undefined : Math.max(0, backendElapsedMs);
+  if (terminal && backend !== undefined) return backend;
+  return Math.max(live, backend ?? 0);
+}
+
+export function tableImportProgressPercent(progress: TableImportProgressLike | null | undefined): number {
+  if (!progress) return 0;
+  if (progress.status === "done") return 100;
+  let percent = 0;
+  const totalRows = progress.totalRows ?? 0;
+  const totalBytes = progress.totalBytes ?? 0;
+  if (progress.phase === "detectingEncoding") {
+    percent = totalBytes > 0 ? ((progress.bytesRead ?? 0) / totalBytes) * 10 : 0;
+  } else if (progress.phase === "writing" || progress.phase === "finalizing") {
+    if (progress.totalRowsExact !== false && totalRows > 0) {
+      percent = 10 + (progress.rowsImported / totalRows) * 89;
+    } else if (totalBytes > 0) {
+      percent = 10 + ((progress.bytesRead ?? 0) / totalBytes) * 89;
+    }
+  } else if (progress.totalRowsExact !== false && totalRows > 0) {
+    percent = (progress.rowsImported / totalRows) * 100;
+  } else if (totalBytes > 0) {
+    percent = ((progress.bytesRead ?? 0) / totalBytes) * 100;
+  }
+  return Math.min(99, Math.max(0, Math.round(percent)));
+}
+
 export interface TableImportParseSettings {
   format: TableImportSourceFormat;
   delimiter: string;
diff --git a/crates/dbx-core/Cargo.toml b/crates/dbx-core/Cargo.toml
index fb96459148..fbff799f54 100644
--- a/crates/dbx-core/Cargo.toml
+++ b/crates/dbx-core/Cargo.toml
@@ -88,3 +88,4 @@ bytes = "1"
 font-kit = "0.14.3"
 zip = { version = "4", default-features = false, features = ["deflate"] }
 sysinfo = { version = "0.32", features = ["system"] }
+tempfile = "3"
diff --git a/crates/dbx-core/examples/table_import_bench.rs b/crates/dbx-core/examples/table_import_bench.rs
new file mode 100644
index 0000000000..da4146b2f5
--- /dev/null
+++ b/crates/dbx-core/examples/table_import_bench.rs
@@ -0,0 +1,211 @@
+use std::fs::{self, File};
+use std::io::{BufWriter, Write};
+use std::path::Path;
+use std::time::Instant;
+
+use dbx_core::models::connection::DatabaseType;
+use dbx_core::table_import::{
+    build_import_insert_batches, parse_delimited_file_with_options, parse_xlsx_file_with_options,
+    preview_table_import_file_with_request, ParsedImportFile, TableImportColumnMapping, TableImportParseOptions,
+    TableImportPreviewRequest, TableImportSourceFormat,
+};
+use dbx_core::xlsx_export::{build_xlsx_workbook, XlsxWorksheetData};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum BenchFormat {
+    Csv,
+    Xlsx,
+    All,
+}
+
+struct Options {
+    rows: usize,
+    columns: usize,
+    batch_size: usize,
+    format: BenchFormat,
+}
+
+fn print_help() {
+    println!(
+        "Table import benchmark\n\n\
+Usage:\n  cargo run -p dbx-core --example table_import_bench --release -- [options]\n\n\
+Options:\n  --rows=10000       Number of data rows\n  --columns=10       Number of columns\n  --batch-size=500   SQL rows per batch\n  --format=all       csv, xlsx, or all\n  --help             Show this help\n"
+    );
+}
+
+fn parse_options() -> Result<Options, String> {
+    let mut options = Options { rows: 10_000, columns: 10, batch_size: 500, format: BenchFormat::All };
+    for argument in std::env::args().skip(1) {
+        if argument == "--help" || argument == "-h" {
+            print_help();
+            std::process::exit(0);
+        }
+        let (key, value) = argument.split_once('=').ok_or_else(|| format!("Invalid option: {argument}"))?;
+        match key {
+            "--rows" => options.rows = value.parse().map_err(|_| format!("Invalid row count: {value}"))?,
+            "--columns" => options.columns = value.parse().map_err(|_| format!("Invalid column count: {value}"))?,
+            "--batch-size" => options.batch_size = value.parse().map_err(|_| format!("Invalid batch size: {value}"))?,
+            "--format" => {
+                options.format = match value {
+                    "csv" => BenchFormat::Csv,
+                    "xlsx" => BenchFormat::Xlsx,
+                    "all" => BenchFormat::All,
+                    _ => return Err(format!("Invalid format: {value}")),
+                }
+            }
+            _ => return Err(format!("Unknown option: {key}")),
+        }
+    }
+    if options.rows == 0 || options.columns == 0 || options.batch_size == 0 {
+        return Err("rows, columns, and batch-size must be greater than zero".to_string());
+    }
+    Ok(options)
+}
+
+fn columns(count: usize) -> Vec<String> {
+    (0..count).map(|index| format!("column_{}", index + 1)).collect()
+}
+
+fn row(row_index: usize, column_count: usize) -> Vec<serde_json::Value> {
+    (0..column_count)
+        .map(|column_index| {
+            if column_index == 0 {
+                serde_json::json!(row_index + 1)
+            } else if column_index % 3 == 0 {
+                serde_json::json!(format!("2026-07-{:02} 12:34:56", row_index % 28 + 1))
+            } else {
+                serde_json::json!(format!("value-{row_index}-{column_index}"))
+            }
+        })
+        .collect()
+}
+
+fn write_csv(path: &Path, row_count: usize, column_count: usize) -> Result<(), String> {
+    let file = File::create(path).map_err(|error| error.to_string())?;
+    let mut writer = BufWriter::new(file);
+    writeln!(writer, "{}", columns(column_count).join(",")).map_err(|error| error.to_string())?;
+    for row_index in 0..row_count {
+        let values = row(row_index, column_count)
+            .into_iter()
+            .map(|value| value.as_str().map(str::to_string).unwrap_or_else(|| value.to_string()))
+            .collect::<Vec<_>>();
+        writeln!(writer, "{}", values.join(",")).map_err(|error| error.to_string())?;
+    }
+    writer.flush().map_err(|error| error.to_string())
+}
+
+fn write_xlsx(path: &Path, row_count: usize, column_count: usize) -> Result<(), String> {
+    let workbook = build_xlsx_workbook(&XlsxWorksheetData {
+        sheet_name: Some("Benchmark".to_string()),
+        columns: columns(column_count),
+        column_types: vec![],
+        rows: (0..row_count).map(|row_index| row(row_index, column_count)).collect(),
+    })?;
+    fs::write(path, workbook).map_err(|error| error.to_string())
+}
+
+fn mappings(data: &ParsedImportFile) -> Vec<TableImportColumnMapping> {
+    data.columns
+        .iter()
+        .map(|column| TableImportColumnMapping {
+            source_column: column.clone(),
+            target_column: column.clone(),
+            target_data_type: None,
+        })
+        .collect()
+}
+
+async fn benchmark_file(
+    path: &Path,
+    format: TableImportSourceFormat,
+    options: &Options,
+) -> Result<serde_json::Value, String> {
+    let path_text = path.to_string_lossy();
+    let parse_options = TableImportParseOptions::default();
+    let preview_started = Instant::now();
+    let preview = preview_table_import_file_with_request(TableImportPreviewRequest {
+        file_path: path_text.to_string(),
+        source_ref: None,
+        source_format: Some(format),
+        parse_options: parse_options.clone(),
+        preview_limit: Some(50),
+    })
+    .await?;
+    let preview_ms = preview_started.elapsed().as_secs_f64() * 1000.0;
+
+    let full_parse_started = Instant::now();
+    let parsed = match format {
+        TableImportSourceFormat::Csv => {
+            parse_delimited_file_with_options(&path_text, format, &parse_options, usize::MAX)?
+        }
+        TableImportSourceFormat::Excel => parse_xlsx_file_with_options(&path_text, &parse_options, usize::MAX)?,
+        _ => unreachable!(),
+    };
+    let full_parse_ms = full_parse_started.elapsed().as_secs_f64() * 1000.0;
+
+    let batch_started = Instant::now();
+    let batches = build_import_insert_batches(
+        &parsed,
+        &mappings(&parsed),
+        &[],
+        "benchmark_import",
+        "main",
+        &DatabaseType::Sqlite,
+        options.batch_size,
+    )?;
+    let batch_build_ms = batch_started.elapsed().as_secs_f64() * 1000.0;
+    let sql_bytes = batches.iter().map(|batch| batch.sql.len()).sum::<usize>();
+
+    Ok(serde_json::json!({
+        "format": format.label(),
+        "fileBytes": fs::metadata(path).map_err(|error| error.to_string())?.len(),
+        "rows": parsed.total_rows,
+        "columns": preview.columns.len(),
+        "previewRows": preview.rows.len(),
+        "previewTotalRowsExact": preview.total_rows_exact,
+        "previewMs": preview_ms,
+        "fullParseMs": full_parse_ms,
+        "batchBuildMs": batch_build_ms,
+        "batchCount": batches.len(),
+        "sqlBytes": sql_bytes,
+    }))
+}
+
+async fn run() -> Result<(), String> {
+    let options = parse_options()?;
+    let temp_dir = std::env::temp_dir().join(format!("dbx-table-import-bench-{}", uuid::Uuid::new_v4()));
+    fs::create_dir_all(&temp_dir).map_err(|error| error.to_string())?;
+    let mut results = Vec::new();
+
+    if matches!(options.format, BenchFormat::Csv | BenchFormat::All) {
+        let path = temp_dir.join("benchmark.csv");
+        write_csv(&path, options.rows, options.columns)?;
+        results.push(benchmark_file(&path, TableImportSourceFormat::Csv, &options).await?);
+    }
+    if matches!(options.format, BenchFormat::Xlsx | BenchFormat::All) {
+        let path = temp_dir.join("benchmark.xlsx");
+        write_xlsx(&path, options.rows, options.columns)?;
+        results.push(benchmark_file(&path, TableImportSourceFormat::Excel, &options).await?);
+    }
+
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&serde_json::json!({
+            "rows": options.rows,
+            "columns": options.columns,
+            "batchSize": options.batch_size,
+            "results": results,
+        }))
+        .map_err(|error| error.to_string())?
+    );
+    let _ = fs::remove_dir_all(temp_dir);
+    Ok(())
+}
+
+#[tokio::main]
+async fn main() {
+    if let Err(error) = run().await {
+        eprintln!("{error}");
+        std::process::exit(1);
+    }
+}
diff --git a/crates/dbx-core/src/connection.rs b/crates/dbx-core/src/connection.rs
index 717b234dcf..138c1cc004 100644
--- a/crates/dbx-core/src/connection.rs
+++ b/crates/dbx-core/src/connection.rs
@@ -2308,9 +2308,38 @@ impl AppState {
         database: Option<&str>,
         client_session_id: &str,
     ) -> Result<bool, String> {
+        let Some((pool_key, pool)) = self.take_client_session_pool(connection_id, database, client_session_id).await?
+        else {
+            return Ok(false);
+        };
+        close_pool_kind_with_timeout(pool_key, pool).await;
+        Ok(true)
+    }
+
+    /// Removes a session-scoped pool immediately and schedules the potentially slow driver
+    /// shutdown on the supervised background task set.
+    pub async fn detach_client_session_pool(
+        &self,
+        connection_id: &str,
+        database: Option<&str>,
+        client_session_id: &str,
+    ) -> Result<bool, String> {
+        let Some(removed) = self.take_client_session_pool(connection_id, database, client_session_id).await? else {
+            return Ok(false);
+        };
+        close_removed_pools_in_background(&self.task_supervisor, vec![removed]);
+        Ok(true)
+    }
+
+    async fn take_client_session_pool(
+        &self,
+        connection_id: &str,
+        database: Option<&str>,
+        client_session_id: &str,
+    ) -> Result<Option<(String, PoolKind)>, String> {
         let session = normalize_client_session_id(Some(client_session_id));
         let Some(session) = session else {
-            return Ok(false);
+            return Ok(None);
         };
         let config = {
             let configs = self.configs.read().await;
@@ -2320,18 +2349,13 @@ impl AppState {
         let base_pool_key = base_pool_key_for(db_type, connection_id, database, false);
         let pool_key = session_scoped_pool_key_for(config.as_ref(), base_pool_key.clone(), Some(&session));
         if pool_key == base_pool_key {
-            return Ok(false);
+            return Ok(None);
         }
         self.stop_keepalive_task(&pool_key).await;
         self.pool_activity.write().await.remove(&pool_key);
         self.postgres_cancel_contexts.write().await.remove(&pool_key);
         let removed = self.connections.write().await.remove(&pool_key);
-        if let Some(pool) = removed {
-            close_pool_kind_with_timeout(pool_key, pool).await;
-            Ok(true)
-        } else {
-            Ok(false)
-        }
+        Ok(removed.map(|pool| (pool_key, pool)))
     }
 
     pub async fn remove_pool_by_key(&self, pool_key: &str) -> bool {
@@ -2453,7 +2477,7 @@ impl AppState {
         self.postgres_cancel_contexts.write().await.remove(pool_key);
         let removed = self.connections.write().await.remove(pool_key);
         if let Some(pool) = removed {
-            close_removed_pools_in_background(vec![(pool_key.to_string(), pool)]);
+            close_removed_pools_in_background(&self.task_supervisor, vec![(pool_key.to_string(), pool)]);
             true
         } else {
             false
@@ -3008,13 +3032,13 @@ impl AppState {
 
     pub async fn remove_connection_pools_detached(&self, connection_id: &str) {
         let removed = self.drain_connection_pools(connection_id).await;
-        close_removed_pools_in_background(removed);
+        close_removed_pools_in_background(&self.task_supervisor, removed);
     }
 
     #[cfg(feature = "duckdb-bundled")]
     async fn remove_duckdb_pools_detached(&self) {
         let removed = self.drain_duckdb_pools().await;
-        close_removed_pools_in_background(removed);
+        close_removed_pools_in_background(&self.task_supervisor, removed);
     }
 
     #[cfg(not(feature = "duckdb-bundled"))]
@@ -3463,13 +3487,19 @@ async fn close_removed_pools(removed: Vec<(String, PoolKind)>) {
     }
 }
 
-fn close_removed_pools_in_background(removed: Vec<(String, PoolKind)>) {
+fn close_removed_pools_in_background(supervisor: &TaskSupervisor, removed: Vec<(String, PoolKind)>) {
     if removed.is_empty() {
         return;
     }
-    tokio::spawn(async move {
+    // Supervision keeps detached cleanup visible to application shutdown instead of leaving an
+    // untracked Tokio task that may be abandoned silently.
+    let pool_count = removed.len();
+    let task_key = format!("pool-close:{}", uuid::Uuid::new_v4());
+    if !supervisor.spawn_once(task_key, move |_| async move {
         close_removed_pools(removed).await;
-    });
+    }) {
+        log::debug!("Dropped {pool_count} detached pool handle(s) during application shutdown");
+    }
 }
 
 async fn close_pool_kind_with_timeout(pool_key: String, pool: PoolKind) {
@@ -5244,6 +5274,26 @@ for line in sys.stdin:
         let _ = std::fs::remove_dir_all(dir);
     }
 
+    #[tokio::test]
+    async fn detach_client_session_pool_removes_pool_before_background_close() {
+        let (state, dir) = test_app_state().await;
+        let mut config = mysql_config(None);
+        config.id = "conn".to_string();
+        config.db_type = DatabaseType::Sqlite;
+        state.configs.write().await.insert(config.id.clone(), config);
+
+        let pool_key = "conn:session:import-1";
+        let pool = crate::db::sqlite::connect_path(":memory:").await.unwrap();
+        state.connections.write().await.insert(pool_key.to_string(), PoolKind::Sqlite(pool));
+        state.pool_activity.write().await.insert(pool_key.to_string(), super::PoolActivity::now());
+
+        assert!(state.detach_client_session_pool("conn", None, "import-1").await.unwrap());
+        assert!(!state.connections.read().await.contains_key(pool_key));
+        assert!(!state.pool_activity.read().await.contains_key(pool_key));
+
+        let _ = std::fs::remove_dir_all(dir);
+    }
+
     #[tokio::test]
     async fn closing_oracle_table_tab_keeps_connection_scoped_pool() {
         let (state, dir) = test_app_state().await;
diff --git a/crates/dbx-core/src/query.rs b/crates/dbx-core/src/query.rs
index 9cea002699..a2a26083c8 100644
--- a/crates/dbx-core/src/query.rs
+++ b/crates/dbx-core/src/query.rs
@@ -2551,17 +2551,30 @@ pub async fn execute_statements_in_transaction(
             .map_err(|e| query_error_with_omitted_sql_context(&e, sql_ctx))?
     };
 
+    execute_statements_in_transaction_on_pool(state, &pool_key, connection_id, database, statements, schema).await
+}
+
+/// Execute multiple SQL statements transactionally on an already-resolved pool.
+/// This preserves session-scoped pools used by long-running imports.
+pub async fn execute_statements_in_transaction_on_pool(
+    state: &AppState,
+    pool_key: &str,
+    connection_id: &str,
+    database: &str,
+    statements: &[String],
+    schema: Option<&str>,
+) -> Result<db::QueryResult, String> {
     // Read-only check: intercept all transaction paths before dispatching
-    check_read_only_for_connection_multi(state, &pool_key, statements).await?;
+    check_read_only_for_connection_multi(state, pool_key, statements).await?;
 
     let start = std::time::Instant::now();
     let db_type = connection_database_type(state, connection_id).await;
-    let operation_budget = configured_operation_budget_for_pool_key(state, &pool_key).await;
+    let operation_budget = configured_operation_budget_for_pool_key(state, pool_key).await;
 
     // Clone the pool handle within the lock, then drop it before any async work.
     let path = {
         let conns = state.connections.read().await;
-        conns.get(&pool_key).map(|p| match p {
+        conns.get(pool_key).map(|p| match p {
             PoolKind::Postgres(pg) => TxPath::Pg(pg.clone()),
             PoolKind::Mysql(mp, _mode) => TxPath::Mysql(mp.clone(), false),
             PoolKind::Sqlite(sq) => TxPath::Sqlite(sq.clone()),
@@ -2597,11 +2610,11 @@ pub async fn execute_statements_in_transaction(
 
     let result = match path {
         Some(TxPath::Pg(pool)) => {
-            let cancel_context = state.get_postgres_cancel_context(&pool_key).await;
+            let cancel_context = state.get_postgres_cancel_context(pool_key).await;
             exec_tx_pg_inner(pool, statements, schema, start, operation_budget.clone(), cancel_context).await
         }
         Some(TxPath::Mysql(pool, _bare)) => {
-            exec_tx_mysql_inner(state, &pool_key, pool, statements, start, operation_budget.clone()).await
+            exec_tx_mysql_inner(state, pool_key, pool, statements, start, operation_budget.clone()).await
         }
         Some(TxPath::Sqlite(pool)) => exec_tx_sqlite_inner(pool, statements, start).await,
         Some(TxPath::CloudflareD1(client)) => {
@@ -2615,18 +2628,18 @@ pub async fn execute_statements_in_transaction(
         }
         Some(TxPath::Explicit) => {
             let mysql_dialect = connection_mysql_query_dialect(state, connection_id).await;
-            exec_tx_explicit_inner(state, &pool_key, mysql_dialect, Some(database), statements, schema, start).await
+            exec_tx_explicit_inner(state, pool_key, mysql_dialect, Some(database), statements, schema, start).await
         }
         Some(TxPath::None) => {
             let mysql_dialect = connection_mysql_query_dialect(state, connection_id).await;
-            exec_tx_none_inner(state, &pool_key, mysql_dialect, Some(database), statements, schema, start).await
+            exec_tx_none_inner(state, pool_key, mysql_dialect, Some(database), statements, schema, start).await
         }
         None => Err("Connection not found for transaction".to_string()),
     };
 
     if let Err(err) = result.as_ref() {
         if matches!(pool_error_action(db_type, err), PoolErrorAction::Discard | PoolErrorAction::ReconnectAndRetry) {
-            state.remove_pool_by_key(&pool_key).await;
+            state.remove_pool_by_key(pool_key).await;
         }
     }
 
diff --git a/crates/dbx-core/src/table_import.rs b/crates/dbx-core/src/table_import.rs
index a8c893f02e..8eb4861d93 100644
--- a/crates/dbx-core/src/table_import.rs
+++ b/crates/dbx-core/src/table_import.rs
@@ -1,25 +1,42 @@
 use std::collections::{HashMap, HashSet};
 use std::fs::File;
-use std::io::{BufRead, BufReader, Read as IoRead, Seek, SeekFrom};
+use std::io::{BufRead, BufReader, Read as IoRead, Seek, SeekFrom, Write as IoWrite};
 use std::path::Path;
 use std::sync::Arc;
+use std::time::{Duration, Instant, UNIX_EPOCH};
 
-use calamine::{open_workbook_auto, Data, ExcelDateTime, Reader as CalamineReader};
+use calamine::{
+    open_workbook_auto, CellType, Data, DataRef, ExcelDateTime, Range, Reader as CalamineReader,
+    ReaderRef as CalamineReaderRef,
+};
 use chrono::{DateTime, NaiveDate, NaiveDateTime};
 use quick_xml::events::{BytesStart, Event};
 use quick_xml::Reader as XmlReader;
 use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
 
-use crate::connection::{task_client_session_id, AppState};
+use crate::connection::{task_client_session_id, AppState, PoolKind};
 use crate::models::connection::DatabaseType;
 use crate::transfer::{
-    execute_on_pool, generate_insert_typed, get_columns_for_transfer, qualified_table, quote_identifier,
+    execute_on_pool, generate_insert_typed, generate_insert_typed_sql_batches, get_columns_for_transfer,
+    qualified_table, quote_identifier,
 };
 
 pub const DEFAULT_PREVIEW_LIMIT: usize = 50;
 pub const DEFAULT_BATCH_SIZE: usize = 500;
 pub const CREATE_TABLE_INFERENCE_ROWS: usize = 100;
 pub const MAX_NON_STREAMING_IMPORT_BYTES: u64 = 100 * 1024 * 1024;
+pub const MAX_LEGACY_XLS_IMPORT_BYTES: u64 = 50 * 1024 * 1024;
+const IMPORT_PROGRESS_INTERVAL: Duration = Duration::from_millis(100);
+// Keep preview parsing bounded even when an XLSX dimension declares a huge sparse range.
+const MAX_FAST_PREVIEW_CELLS: usize = 100_000;
+// Shared strings stay in memory for small workbooks and spill to an indexed temp file for large ones.
+const MAX_IN_MEMORY_XLSX_SHARED_STRINGS_BYTES: u64 = 8 * 1024 * 1024;
+const MAX_XLSX_SHARED_STRINGS_BYTES: u64 = 1024 * 1024 * 1024;
+const XLSX_SHARED_STRING_CACHE_ENTRIES: usize = 4096;
+const XLSX_SHARED_STRING_CACHE_BYTES: usize = 8 * 1024 * 1024;
+// INSERT ALL has a practical statement-size limit on Oracle, even when the requested batch is larger.
+const MAX_ORACLE_IMPORT_BATCH_ROWS: usize = 500;
 
 pub fn table_import_client_session_id(import_id: &str) -> String {
     task_client_session_id("table-import", import_id)
@@ -39,6 +56,13 @@ pub struct ImportSqlBatch {
     pub row_count: usize,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct CompiledImportPlan {
+    mapped_source_indexes: Vec<usize>,
+    target_columns: Vec<String>,
+    column_types: Vec<Option<String>>,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ImportCreateTableColumn {
     pub name: String,
@@ -203,6 +227,23 @@ pub struct TableImportRequest {
     pub batch_size: usize,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub date_time_format: Option<String>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub prepared_source: Option<TableImportPreparedSource>,
+    #[serde(default)]
+    pub retain_source: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TableImportPreparedSource {
+    pub fingerprint: String,
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<serde_json::Value>>,
+    pub total_rows: usize,
+    #[serde(default = "default_true")]
+    pub total_rows_exact: bool,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub effective_encoding: Option<TableImportTextEncoding>,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -217,6 +258,8 @@ pub struct TableImportPreview {
     pub columns: Vec<String>,
     pub rows: Vec<Vec<serde_json::Value>>,
     pub total_rows: usize,
+    pub total_rows_exact: bool,
+    pub source_fingerprint: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub effective_encoding: Option<TableImportTextEncoding>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
@@ -229,6 +272,7 @@ pub struct TableImportSummary {
     pub import_id: String,
     pub rows_imported: usize,
     pub total_rows: usize,
+    pub elapsed_ms: u128,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -236,12 +280,17 @@ pub struct TableImportSummary {
 pub struct TableImportProgress {
     pub import_id: String,
     pub status: TableImportStatus,
+    pub phase: TableImportPhase,
     pub rows_imported: usize,
     pub total_rows: usize,
+    pub total_rows_exact: bool,
+    pub bytes_read: u64,
+    pub total_bytes: u64,
+    pub elapsed_ms: u128,
     pub error: Option<String>,
 }
 
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub enum TableImportStatus {
     Running,
@@ -250,6 +299,21 @@ pub enum TableImportStatus {
     Cancelled,
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub enum TableImportPhase {
+    Preparing,
+    DetectingEncoding,
+    Reading,
+    Writing,
+    Finalizing,
+    Done,
+}
+
+const fn default_true() -> bool {
+    true
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ImportFileKind {
     Csv,
@@ -403,6 +467,7 @@ pub fn csv_value(value: &str) -> serde_json::Value {
 
 const IMPORT_ENCODING_READ_CHUNK_BYTES: usize = 16 * 1024;
 
+// Decodes incrementally and rejects malformed input instead of silently inserting replacement characters.
 struct StrictTranscodingReader<R> {
     reader: R,
     decoder: encoding_rs::Decoder,
@@ -412,6 +477,7 @@ struct StrictTranscodingReader<R> {
     output_offset: usize,
     reached_eof: bool,
     finished: bool,
+    source_bytes_read: u64,
 }
 
 impl<R: IoRead> StrictTranscodingReader<R> {
@@ -429,9 +495,14 @@ impl<R: IoRead> StrictTranscodingReader<R> {
             output_offset: 0,
             reached_eof: false,
             finished: false,
+            source_bytes_read: 0,
         })
     }
 
+    fn source_bytes_read(&self) -> u64 {
+        self.source_bytes_read
+    }
+
     fn invalid_data_error(&self) -> std::io::Error {
         std::io::Error::new(
             std::io::ErrorKind::InvalidData,
@@ -465,6 +536,7 @@ impl<R: IoRead> IoRead for StrictTranscodingReader<R> {
             if self.pending_input.is_empty() && !self.reached_eof {
                 let mut input = [0u8; IMPORT_ENCODING_READ_CHUNK_BYTES];
                 let read = self.reader.read(&mut input)?;
+                self.source_bytes_read = self.source_bytes_read.saturating_add(read as u64);
                 if read == 0 {
                     self.reached_eof = true;
                 } else {
@@ -477,12 +549,14 @@ impl<R: IoRead> IoRead for StrictTranscodingReader<R> {
                 .max_utf8_buffer_length_without_replacement(self.pending_input.len())
                 .unwrap_or(self.pending_input.len().saturating_mul(3).saturating_add(4))
                 .max(4);
-            let mut output = vec![0u8; output_capacity];
-            let (result, read, written) =
-                self.decoder.decode_to_utf8_without_replacement(&self.pending_input, &mut output, self.reached_eof);
+            self.pending_output.resize(output_capacity, 0);
+            let (result, read, written) = self.decoder.decode_to_utf8_without_replacement(
+                &self.pending_input,
+                &mut self.pending_output,
+                self.reached_eof,
+            );
             self.pending_input.drain(..read);
-            output.truncate(written);
-            self.pending_output = output;
+            self.pending_output.truncate(written);
 
             match result {
                 encoding_rs::DecoderResult::Malformed(_, _) => return Err(self.invalid_data_error()),
@@ -518,6 +592,35 @@ fn reader_is_valid_for_encoding<R: IoRead>(reader: R, encoding: TableImportTextE
     }
 }
 
+fn validate_text_encoding_from_file_with_progress(
+    path: &str,
+    encoding: TableImportTextEncoding,
+    bom_len: usize,
+    mut on_progress: impl FnMut(u64),
+) -> Result<(), String> {
+    let total_bytes = std::fs::metadata(path).map(|metadata| metadata.len()).unwrap_or_default();
+    let mut file = File::open(path).map_err(|error| error.to_string())?;
+    file.seek(SeekFrom::Start(bom_len as u64)).map_err(|error| error.to_string())?;
+    let mut reader = StrictTranscodingReader::new(file, encoding)?;
+    let mut buffer = [0u8; IMPORT_ENCODING_READ_CHUNK_BYTES];
+    let mut last_reported = None;
+    loop {
+        let read = reader.read(&mut buffer).map_err(|error| error.to_string())?;
+        let bytes_read = (bom_len as u64).saturating_add(reader.source_bytes_read()).min(total_bytes);
+        if last_reported != Some(bytes_read) {
+            on_progress(bytes_read);
+            last_reported = Some(bytes_read);
+        }
+        if read == 0 {
+            break;
+        }
+    }
+    if total_bytes > 0 && last_reported != Some(total_bytes) {
+        on_progress(total_bytes);
+    }
+    Ok(())
+}
+
 fn auto_detect_text_encoding_from_bytes(bytes: &[u8]) -> Result<(TableImportTextEncoding, usize), String> {
     if let Some(detected) = bom_text_encoding(bytes) {
         return Ok(detected);
@@ -542,30 +645,103 @@ fn resolve_text_encoding_from_bytes(
     }
 }
 
-fn auto_detect_text_encoding_from_file(path: &str) -> Result<(TableImportTextEncoding, usize), String> {
+struct EncodingValidationState {
+    decoder: encoding_rs::Decoder,
+    pending: Vec<u8>,
+    output: Vec<u8>,
+    valid: bool,
+}
+
+impl EncodingValidationState {
+    fn new(encoding: &'static encoding_rs::Encoding) -> Self {
+        Self {
+            decoder: encoding.new_decoder_without_bom_handling(),
+            pending: Vec::new(),
+            output: Vec::new(),
+            valid: true,
+        }
+    }
+
+    fn push(&mut self, input: &[u8], last: bool) {
+        if !self.valid {
+            return;
+        }
+        self.pending.extend_from_slice(input);
+        loop {
+            let output_capacity = self
+                .decoder
+                .max_utf8_buffer_length_without_replacement(self.pending.len())
+                .unwrap_or(self.pending.len().saturating_mul(3).saturating_add(4))
+                .max(4);
+            self.output.resize(output_capacity, 0);
+            let (result, read, _) =
+                self.decoder.decode_to_utf8_without_replacement(&self.pending, &mut self.output, last);
+            self.pending.drain(..read);
+            match result {
+                encoding_rs::DecoderResult::Malformed(_, _) => {
+                    self.valid = false;
+                    self.pending.clear();
+                    return;
+                }
+                encoding_rs::DecoderResult::InputEmpty => return,
+                encoding_rs::DecoderResult::OutputFull if read == 0 => {
+                    self.valid = false;
+                    self.pending.clear();
+                    return;
+                }
+                encoding_rs::DecoderResult::OutputFull => {}
+            }
+        }
+    }
+}
+
+fn auto_detect_text_encoding_from_file_with_progress(
+    path: &str,
+    mut on_progress: impl FnMut(u64),
+) -> Result<(TableImportTextEncoding, usize), String> {
     let mut file = File::open(path).map_err(|error| error.to_string())?;
     let mut prefix = [0u8; 3];
     let prefix_len = file.read(&mut prefix).map_err(|error| error.to_string())?;
-    if let Some(detected) = bom_text_encoding(&prefix[..prefix_len]) {
-        return Ok(detected);
+    if let Some((detected, bom_len)) = bom_text_encoding(&prefix[..prefix_len]) {
+        validate_text_encoding_from_file_with_progress(path, detected, bom_len, &mut on_progress)?;
+        return Ok((detected, bom_len));
     }
 
-    for encoding in [TableImportTextEncoding::Utf8, TableImportTextEncoding::Gbk] {
-        let file = File::open(path).map_err(|error| error.to_string())?;
-        if reader_is_valid_for_encoding(file, encoding)? {
-            return Ok((encoding, 0));
+    file.seek(SeekFrom::Start(0)).map_err(|error| error.to_string())?;
+    // Validate both candidates incrementally so auto-detection does not load the file into memory.
+    let mut utf8 = EncodingValidationState::new(encoding_rs::UTF_8);
+    let mut gbk = EncodingValidationState::new(encoding_rs::GBK);
+    let mut bytes_read = 0u64;
+    let mut input = [0u8; IMPORT_ENCODING_READ_CHUNK_BYTES];
+    loop {
+        let read = file.read(&mut input).map_err(|error| error.to_string())?;
+        if read == 0 {
+            utf8.push(&[], true);
+            gbk.push(&[], true);
+            break;
         }
+        utf8.push(&input[..read], false);
+        gbk.push(&input[..read], false);
+        bytes_read = bytes_read.saturating_add(read as u64);
+        on_progress(bytes_read);
+    }
+    if utf8.valid {
+        return Ok((TableImportTextEncoding::Utf8, 0));
+    }
+    if gbk.valid {
+        return Ok((TableImportTextEncoding::Gbk, 0));
     }
     Err("Could not detect text encoding; select UTF-8, GBK / GB18030, or UTF-16 manually".to_string())
 }
 
-fn resolve_text_encoding_from_file(
+fn resolve_text_encoding_from_file_with_progress(
     path: &str,
     requested: Option<TableImportTextEncoding>,
+    on_progress: impl FnMut(u64),
 ) -> Result<(TableImportTextEncoding, usize), String> {
     let requested = requested.unwrap_or(TableImportTextEncoding::Auto);
     if requested == TableImportTextEncoding::Auto {
-        return auto_detect_text_encoding_from_file(path);
+        return auto_detect_text_encoding_from_file_with_progress(path, on_progress);
     }
 
     let mut file = File::open(path).map_err(|error| error.to_string())?;
@@ -574,13 +750,34 @@ fn resolve_text_encoding_from_file(
     Ok((requested, matching_bom_len(&prefix[..prefix_len], requested)))
 }
 
-fn open_delimited_csv_reader(
+fn resolve_and_validate_text_encoding_from_file(
+    path: &str,
+    requested: Option<TableImportTextEncoding>,
+    mut on_progress: impl FnMut(u64),
+) -> Result<(TableImportTextEncoding, usize), String> {
+    let requested = requested.unwrap_or(TableImportTextEncoding::Auto);
+    let (encoding, bom_len) = if requested == TableImportTextEncoding::Auto {
+        auto_detect_text_encoding_from_file_with_progress(path, &mut on_progress)?
+    } else {
+        let mut file = File::open(path).map_err(|error| error.to_string())?;
+        let mut prefix = [0u8; 3];
+        let prefix_len = file.read(&mut prefix).map_err(|error| error.to_string())?;
+        let bom_len = matching_bom_len(&prefix[..prefix_len], requested);
+        validate_text_encoding_from_file_with_progress(path, requested, bom_len, on_progress)?;
+        (requested, bom_len)
+    };
+    Ok((encoding, bom_len))
+}
+
+fn open_delimited_csv_reader_with_progress(
     path: &str,
     source_format: TableImportSourceFormat,
     options: &TableImportParseOptions,
+    on_encoding_progress: impl FnMut(u64),
 ) -> Result<(csv::Reader<StrictTranscodingReader<File>>, DelimitedParseConfig, TableImportTextEncoding), String> {
     let config = effective_delimited_config(source_format, options)?;
-    let (encoding, bom_len) = resolve_text_encoding_from_file(path, options.encoding)?;
+    let (encoding, bom_len) =
+        resolve_text_encoding_from_file_with_progress(path, options.encoding, on_encoding_progress)?;
     let mut file = File::open(path).map_err(|error| error.to_string())?;
     file.seek(SeekFrom::Start(bom_len as u64)).map_err(|error| error.to_string())?;
     let transcoded = StrictTranscodingReader::new(file, encoding)?;
@@ -625,7 +822,33 @@ pub fn parse_delimited_file_with_options(
     options: &TableImportParseOptions,
     preview_limit: usize,
 ) -> Result<ParsedImportFile, String> {
-    let (reader, config, encoding) = open_delimited_csv_reader(path, source_format, options)?;
+    if options.encoding.unwrap_or(TableImportTextEncoding::Auto) == TableImportTextEncoding::Auto {
+        let mut file = File::open(path).map_err(|error| error.to_string())?;
+        let mut prefix = [0u8; 3];
+        let prefix_len = file.read(&mut prefix).map_err(|error| error.to_string())?;
+        if let Some((encoding, _)) = bom_text_encoding(&prefix[..prefix_len]) {
+            let mut explicit_options = options.clone();
+            explicit_options.encoding = Some(encoding);
+            let (reader, config, encoding) =
+                open_delimited_csv_reader_with_progress(path, source_format, &explicit_options, |_| {})?;
+            return parse_csv_reader(reader, config, preview_limit, encoding);
+        }
+
+        for encoding in [TableImportTextEncoding::Utf8, TableImportTextEncoding::Gbk] {
+            let mut explicit_options = options.clone();
+            explicit_options.encoding = Some(encoding);
+            let (reader, config, encoding) =
+                open_delimited_csv_reader_with_progress(path, source_format, &explicit_options, |_| {})?;
+            match parse_csv_reader(reader, config, preview_limit, encoding) {
+                Ok(parsed) => return Ok(parsed),
+                Err(error) if error.starts_with("Invalid byte sequence for ") => continue,
+                Err(error) => return Err(error),
+            }
+        }
+        return Err("Could not detect text encoding; select UTF-8, GBK / GB18030, or UTF-16 manually".to_string());
+    }
+
+    let (reader, config, encoding) = open_delimited_csv_reader_with_progress(path, source_format, options, |_| {})?;
     parse_csv_reader(reader, config, preview_limit, encoding)
 }
 
@@ -634,13 +857,34 @@ fn parse_csv_reader<R: IoRead>(
     config: DelimitedParseConfig,
     preview_limit: usize,
     effective_encoding: TableImportTextEncoding,
+) -> Result<ParsedImportFile, String> {
+    parse_csv_reader_inner(&mut reader, config, preview_limit, effective_encoding, true)
+}
+
+fn parse_csv_reader_bounded<R: IoRead>(
+    mut reader: csv::Reader<R>,
+    config: DelimitedParseConfig,
+    preview_limit: usize,
+    effective_encoding: TableImportTextEncoding,
+) -> Result<ParsedImportFile, String> {
+    parse_csv_reader_inner(&mut reader, config, preview_limit.max(1), effective_encoding, false)
+}
+
+fn parse_csv_reader_inner<R: IoRead>(
+    reader: &mut csv::Reader<R>,
+    config: DelimitedParseConfig,
+    preview_limit: usize,
+    effective_encoding: TableImportTextEncoding,
+    count_all_rows: bool,
 ) -> Result<ParsedImportFile, String> {
     let mut rows = Vec::new();
     let mut total_rows = 0;
     let mut columns = Vec::new();
-    for (index, record) in reader.records().enumerate() {
-        let record = record.map_err(|e| e.to_string())?;
-        let row_number = index + 1;
+    let mut record = csv::StringRecord::new();
+    let mut index = 0usize;
+    while reader.read_record(&mut record).map_err(|e| e.to_string())? {
+        index += 1;
+        let row_number = index;
         if config.row_range.title_row == Some(row_number) {
             columns = record
                 .iter()
@@ -659,10 +903,12 @@ fn parse_csv_reader<R: IoRead>(
             columns = (0..record.len()).map(|index| format!("column_{}", index + 1)).collect();
         }
         total_rows += 1;
-        if rows.len() >= preview_limit {
-            continue;
+        if rows.len() < preview_limit {
+            rows.push(delimited_record_to_row(&record, columns.len(), config));
+        }
+        if !count_all_rows && rows.len() >= preview_limit {
+            break;
         }
-        rows.push(delimited_record_to_row(&record, columns.len(), config));
     }
     if columns.is_empty() {
         return Err("Import file has no columns in the selected row range".to_string());
@@ -673,6 +919,42 @@ fn parse_csv_reader<R: IoRead>(
     Ok(ParsedImportFile { columns, rows, total_rows, effective_encoding: Some(effective_encoding) })
 }
 
+fn parse_delimited_preview_file_with_options(
+    path: &str,
+    source_format: TableImportSourceFormat,
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+) -> Result<ParsedImportFile, String> {
+    if options.encoding.unwrap_or(TableImportTextEncoding::Auto) == TableImportTextEncoding::Auto {
+        let mut file = File::open(path).map_err(|error| error.to_string())?;
+        let mut prefix = [0u8; 3];
+        let prefix_len = file.read(&mut prefix).map_err(|error| error.to_string())?;
+        if let Some((encoding, _)) = bom_text_encoding(&prefix[..prefix_len]) {
+            let mut explicit_options = options.clone();
+            explicit_options.encoding = Some(encoding);
+            let (reader, config, encoding) =
+                open_delimited_csv_reader_with_progress(path, source_format, &explicit_options, |_| {})?;
+            return parse_csv_reader_bounded(reader, config, preview_limit, encoding);
+        }
+
+        for encoding in [TableImportTextEncoding::Utf8, TableImportTextEncoding::Gbk] {
+            let mut explicit_options = options.clone();
+            explicit_options.encoding = Some(encoding);
+            let (reader, config, encoding) =
+                open_delimited_csv_reader_with_progress(path, source_format, &explicit_options, |_| {})?;
+            match parse_csv_reader_bounded(reader, config, preview_limit, encoding) {
+                Ok(parsed) => return Ok(parsed),
+                Err(error) if error.starts_with("Invalid byte sequence for ") => continue,
+                Err(error) => return Err(error),
+            }
+        }
+        return Err("Could not detect text encoding; select UTF-8, GBK / GB18030, or UTF-16 manually".to_string());
+    }
+
+    let (reader, config, encoding) = open_delimited_csv_reader_with_progress(path, source_format, options, |_| {})?;
+    parse_csv_reader_bounded(reader, config, preview_limit, encoding)
+}
+
 pub fn parse_csv_bytes(bytes: &[u8], preview_limit: usize) -> Result<ParsedImportFile, String> {
     parse_delimited_bytes_with_options(
         bytes,
@@ -912,16 +1194,53 @@ pub fn xlsx_cell_label(cell: &Data) -> String {
     xlsx_cell_label_with_temporal_kind(cell, None)
 }
 
+fn xlsx_cell_ref_value_with_temporal_kind(
+    cell: &DataRef<'_>,
+    temporal_kind: Option<XlsxTemporalKind>,
+) -> serde_json::Value {
+    match cell {
+        DataRef::Empty => serde_json::Value::Null,
+        DataRef::String(s) => csv_value(s),
+        DataRef::SharedString(s) => csv_value(s),
+        DataRef::Float(n) => {
+            serde_json::Number::from_f64(*n).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+        }
+        DataRef::Int(n) => serde_json::Value::Number((*n).into()),
+        DataRef::Bool(v) => serde_json::Value::Bool(*v),
+        DataRef::DateTime(v) => serde_json::Value::String(xlsx_datetime_label(v, temporal_kind)),
+        DataRef::DateTimeIso(v) => serde_json::Value::String(v.clone()),
+        DataRef::DurationIso(v) => serde_json::Value::String(v.clone()),
+        DataRef::Error(v) => serde_json::Value::String(v.to_string()),
+    }
+}
+
+fn xlsx_cell_ref_label_with_temporal_kind(cell: &DataRef<'_>, temporal_kind: Option<XlsxTemporalKind>) -> String {
+    match cell {
+        DataRef::Empty => String::new(),
+        DataRef::String(s) => s.clone(),
+        DataRef::SharedString(s) => (*s).to_string(),
+        DataRef::Float(n) => n.to_string(),
+        DataRef::Int(n) => n.to_string(),
+        DataRef::Bool(v) => v.to_string(),
+        DataRef::DateTime(v) => xlsx_datetime_label(v, temporal_kind),
+        DataRef::DateTimeIso(v) => v.clone(),
+        DataRef::DurationIso(v) => v.clone(),
+        DataRef::Error(v) => v.to_string(),
+    }
+}
+
 pub fn xlsx_sheet_names(path: &str) -> Result<Vec<String>, String> {
-    let workbook = open_workbook_auto(path).map_err(|e| e.to_string())?;
-    Ok(workbook.sheet_names().to_vec())
+    let file = File::open(path).map_err(|error| error.to_string())?;
+    let mut zip = zip::ZipArchive::new(file).map_err(|error| error.to_string())?;
+    let workbook_xml = read_xlsx_zip_text(&mut zip, "xl/workbook.xml")?;
+    Ok(xlsx_workbook_sheet_refs(&workbook_xml).into_iter().map(|(name, _)| name).collect())
 }
 
 fn xml_local_name_eq(name: &[u8], expected: &[u8]) -> bool {
     name.rsplit(|byte| *byte == b':').next().is_some_and(|local| local.eq_ignore_ascii_case(expected))
 }
 
-fn xml_attr_value<R: BufRead>(reader: &XmlReader<R>, element: &BytesStart<'_>, key: &[u8]) -> Option<String> {
+fn xml_attr_value<R>(reader: &XmlReader<R>, element: &BytesStart<'_>, key: &[u8]) -> Option<String> {
     element.attributes().flatten().find_map(|attr| {
         if xml_local_name_eq(attr.key.as_ref(), key) {
             attr.decode_and_unescape_value(reader.decoder()).ok().map(|value| value.into_owned())
@@ -1120,6 +1439,25 @@ fn xlsx_sheet_path_for_name(workbook_xml: &str, rels_xml: &str, sheet_name: &str
         .or_else(|| Some(format!("xl/worksheets/sheet{}.xml", index + 1)))
 }
 
+fn xlsx_workbook_uses_1904_date_system(workbook_xml: &str) -> bool {
+    let mut reader = XmlReader::from_str(workbook_xml);
+    reader.config_mut().trim_text(true);
+    let mut buf = Vec::new();
+    loop {
+        match reader.read_event_into(&mut buf) {
+            Ok(Event::Start(element)) | Ok(Event::Empty(element))
+                if xml_local_name_eq(element.name().as_ref(), b"workbookPr") =>
+            {
+                return xml_attr_value(&reader, &element, b"date1904")
+                    .is_some_and(|value| matches!(value.trim().to_ascii_lowercase().as_str(), "1" | "true"));
+            }
+            Ok(Event::Eof) | Err(_) => return false,
+            _ => {}
+        }
+        buf.clear();
+    }
+}
+
 fn xlsx_cell_ref_position(reference: &str) -> Option<(usize, usize)> {
     let mut column = 0usize;
     let mut row = 0usize;
@@ -1190,6 +1528,511 @@ fn read_xlsx_zip_text(zip: &mut zip::ZipArchive<File>, path: &str) -> Result<Str
     Ok(content)
 }
 
+#[derive(Debug, Default)]
+struct XlsxPreviewRawCell {
+    cell_type: Option<String>,
+    style_id: Option<usize>,
+    value: String,
+    inline_value: String,
+}
+
+fn xlsx_dimension_bounds(reference: &str) -> Option<((usize, usize), (usize, usize))> {
+    let mut parts = reference.split(':');
+    let start = xlsx_cell_ref_position(parts.next()?)?;
+    let end = parts.next().and_then(xlsx_cell_ref_position).unwrap_or(start);
+    Some((start, end))
+}
+
+fn read_xlsx_shared_strings(
+    zip: &mut zip::ZipArchive<File>,
+    needed: &HashSet<usize>,
+) -> Result<HashMap<usize, String>, String> {
+    if needed.is_empty() {
+        return Ok(HashMap::new());
+    }
+    let max_needed = needed.iter().copied().max().unwrap_or_default();
+    let file = zip.by_name("xl/sharedStrings.xml").map_err(|error| error.to_string())?;
+    let mut reader = XmlReader::from_reader(BufReader::new(file));
+    reader.config_mut().trim_text(false);
+    let mut buf = Vec::new();
+    let mut index = 0usize;
+    let mut in_item = false;
+    let mut in_text = false;
+    let mut phonetic_depth = 0usize;
+    let mut current = String::new();
+    let mut strings = HashMap::new();
+    loop {
+        match reader.read_event_into(&mut buf) {
+            Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"si") => {
+                in_item = true;
+                current.clear();
+            }
+            Ok(Event::Start(element)) if in_item && xml_local_name_eq(element.name().as_ref(), b"t") => {
+                in_text = phonetic_depth == 0;
+            }
+            Ok(Event::Start(element)) if in_item && xml_local_name_eq(element.name().as_ref(), b"rPh") => {
+                phonetic_depth = phonetic_depth.saturating_add(1);
+            }
+            Ok(Event::Text(text)) if in_item && in_text => {
+                current.push_str(&text.unescape().map_err(|error| error.to_string())?);
+            }
+            Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"t") => {
+                in_text = false;
+            }
+            Ok(Event::End(element)) if in_item && xml_local_name_eq(element.name().as_ref(), b"rPh") => {
+                phonetic_depth = phonetic_depth.saturating_sub(1);
+            }
+            Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"si") => {
+                if needed.contains(&index) {
+                    strings.insert(index, current.clone());
+                }
+                if index >= max_needed && strings.len() == needed.len() {
+                    break;
+                }
+                index += 1;
+                in_item = false;
+                phonetic_depth = 0;
+            }
+            Ok(Event::Eof) => break,
+            Err(error) => return Err(error.to_string()),
+            _ => {}
+        }
+        buf.clear();
+    }
+    Ok(strings)
+}
+
+struct XlsxDiskSharedStrings {
+    file: File,
+    index: File,
+    count: usize,
+    cache: HashMap<usize, String>,
+    cache_bytes: usize,
+}
+
+enum XlsxSharedStrings {
+    Memory(Vec<String>),
+    Disk(XlsxDiskSharedStrings),
+}
+
+impl XlsxSharedStrings {
+    fn push(&mut self, value: &str) -> Result<(), String> {
+        match self {
+            Self::Memory(strings) => strings.push(value.to_string()),
+            Self::Disk(store) => {
+                let offset = store.file.stream_position().map_err(|error| error.to_string())?;
+                let len = u32::try_from(value.len()).map_err(|_| "Excel shared string is too large".to_string())?;
+                store.file.write_all(value.as_bytes()).map_err(|error| error.to_string())?;
+                store.index.write_all(&offset.to_le_bytes()).map_err(|error| error.to_string())?;
+                store.index.write_all(&len.to_le_bytes()).map_err(|error| error.to_string())?;
+                store.count = store.count.saturating_add(1);
+            }
+        }
+        Ok(())
+    }
+
+    fn get(&mut self, index: usize) -> Result<Option<String>, String> {
+        match self {
+            Self::Memory(strings) => Ok(strings.get(index).cloned()),
+            Self::Disk(store) => {
+                if let Some(value) = store.cache.get(&index) {
+                    return Ok(Some(value.clone()));
+                }
+                if index >= store.count {
+                    return Ok(None);
+                }
+                let index_offset = (index as u64).saturating_mul(12);
+                store.index.seek(SeekFrom::Start(index_offset)).map_err(|error| error.to_string())?;
+                let mut offset_bytes = [0u8; 8];
+                let mut len_bytes = [0u8; 4];
+                store.index.read_exact(&mut offset_bytes).map_err(|error| error.to_string())?;
+                store.index.read_exact(&mut len_bytes).map_err(|error| error.to_string())?;
+                let offset = u64::from_le_bytes(offset_bytes);
+                let len = u32::from_le_bytes(len_bytes);
+                store.file.seek(SeekFrom::Start(offset)).map_err(|error| error.to_string())?;
+                let mut bytes = vec![0; len as usize];
+                store.file.read_exact(&mut bytes).map_err(|error| error.to_string())?;
+                let value = String::from_utf8(bytes).map_err(|error| error.to_string())?;
+                // This cache is opportunistic; clearing it wholesale keeps lookup simple while
+                // enforcing both the entry-count and byte-size bounds.
+                if store.cache.len() >= XLSX_SHARED_STRING_CACHE_ENTRIES
+                    || store.cache_bytes.saturating_add(value.len()) > XLSX_SHARED_STRING_CACHE_BYTES
+                {
+                    store.cache.clear();
+                    store.cache_bytes = 0;
+                }
+                if value.len() <= XLSX_SHARED_STRING_CACHE_BYTES {
+                    store.cache_bytes = store.cache_bytes.saturating_add(value.len());
+                    store.cache.insert(index, value.clone());
+                }
+                Ok(Some(value))
+            }
+        }
+    }
+
+    #[cfg(test)]
+    fn disk_files(&self) -> Option<(&File, &File)> {
+        match self {
+            Self::Memory(_) => None,
+            Self::Disk(store) => Some((&store.file, &store.index)),
+        }
+    }
+}
+
+fn create_xlsx_spill_file() -> std::io::Result<File> {
+    let file = tempfile::tempfile()?;
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        file.set_permissions(std::fs::Permissions::from_mode(0o600))?;
+    }
+    Ok(file)
+}
+
+fn open_xlsx_shared_strings(zip: &mut zip::ZipArchive<File>, memory_limit: u64) -> Result<XlsxSharedStrings, String> {
+    let uncompressed_size = match zip.by_name("xl/sharedStrings.xml") {
+        Ok(file) => file.size(),
+        Err(zip::result::ZipError::FileNotFound) => return Ok(XlsxSharedStrings::Memory(Vec::new())),
+        Err(error) => return Err(error.to_string()),
+    };
+    if uncompressed_size > MAX_XLSX_SHARED_STRINGS_BYTES {
+        return Err(format!(
+            "Excel shared strings are too large: {uncompressed_size} bytes (max {MAX_XLSX_SHARED_STRINGS_BYTES} bytes)"
+        ));
+    }
+    // A fixed-width offset/length index lets cell parsing seek individual strings without
+    // retaining the entire sharedStrings.xml payload in RAM.
+    let mut strings = if uncompressed_size <= memory_limit {
+        XlsxSharedStrings::Memory(Vec::new())
+    } else {
+        // Anonymous temporary files are owner-only on Unix and are removed by the OS when
+        // their last handles close, including after abnormal process termination.
+        let file = create_xlsx_spill_file().map_err(|error| error.to_string())?;
+        let index = create_xlsx_spill_file().map_err(|error| error.to_string())?;
+        XlsxSharedStrings::Disk(XlsxDiskSharedStrings { file, index, count: 0, cache: HashMap::new(), cache_bytes: 0 })
+    };
+
+    let file = zip.by_name("xl/sharedStrings.xml").map_err(|error| error.to_string())?;
+    let mut reader = XmlReader::from_reader(BufReader::new(file));
+    reader.config_mut().trim_text(false);
+    let mut buffer = Vec::new();
+    let mut in_item = false;
+    let mut in_text = false;
+    let mut phonetic_depth = 0usize;
+    let mut current = String::new();
+    loop {
+        match reader.read_event_into(&mut buffer) {
+            Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"si") => {
+                in_item = true;
+                current.clear();
+            }
+            Ok(Event::Start(element)) if in_item && xml_local_name_eq(element.name().as_ref(), b"t") => {
+                in_text = phonetic_depth == 0;
+            }
+            Ok(Event::Start(element)) if in_item && xml_local_name_eq(element.name().as_ref(), b"rPh") => {
+                phonetic_depth = phonetic_depth.saturating_add(1);
+            }
+            Ok(Event::Text(text)) if in_item && in_text => {
+                current.push_str(&text.unescape().map_err(|error| error.to_string())?);
+            }
+            Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"t") => {
+                in_text = false;
+            }
+            Ok(Event::End(element)) if in_item && xml_local_name_eq(element.name().as_ref(), b"rPh") => {
+                phonetic_depth = phonetic_depth.saturating_sub(1);
+            }
+            Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"si") => {
+                strings.push(&current)?;
+                in_item = false;
+                phonetic_depth = 0;
+            }
+            Ok(Event::Eof) => break,
+            Err(error) => return Err(error.to_string()),
+            _ => {}
+        }
+        buffer.clear();
+    }
+    if let XlsxSharedStrings::Disk(store) = &mut strings {
+        store.file.flush().map_err(|error| error.to_string())?;
+        store.index.flush().map_err(|error| error.to_string())?;
+    }
+    Ok(strings)
+}
+
+fn xlsx_preview_cell_value(
+    cell: &XlsxPreviewRawCell,
+    shared_strings: &HashMap<usize, String>,
+    styles: &[XlsxCellStyle],
+    date_1904: bool,
+) -> serde_json::Value {
+    let cell_type = cell.cell_type.as_deref().unwrap_or_default();
+    match cell_type {
+        "s" => cell
+            .value
+            .parse::<usize>()
+            .ok()
+            .and_then(|index| shared_strings.get(&index))
+            .map_or(serde_json::Value::Null, |value| csv_value(value)),
+        "inlineStr" => csv_value(&cell.inline_value),
+        "str" | "d" | "e" => csv_value(&cell.value),
+        "b" => serde_json::Value::Bool(matches!(cell.value.trim(), "1" | "true" | "TRUE")),
+        _ => {
+            let Some(number) = cell.value.trim().parse::<f64>().ok() else {
+                return if cell.value.is_empty() { serde_json::Value::Null } else { csv_value(&cell.value) };
+            };
+            let temporal_kind = cell.style_id.and_then(|style| styles.get(style)?.temporal_kind);
+            if let Some(kind) = temporal_kind {
+                let date_type = if kind == XlsxTemporalKind::Duration {
+                    calamine::ExcelDateTimeType::TimeDelta
+                } else {
+                    calamine::ExcelDateTimeType::DateTime
+                };
+                let value = ExcelDateTime::new(number, date_type, date_1904);
+                return serde_json::Value::String(xlsx_datetime_label(&value, Some(kind)));
+            }
+            serde_json::Number::from_f64(number).map(serde_json::Value::Number).unwrap_or(serde_json::Value::Null)
+        }
+    }
+}
+
+fn xlsx_preview_cell_label(value: &serde_json::Value) -> String {
+    match value {
+        serde_json::Value::Null => String::new(),
+        serde_json::Value::String(value) => value.clone(),
+        serde_json::Value::Bool(value) => value.to_string(),
+        serde_json::Value::Number(value) => value.to_string(),
+        value => value.to_string(),
+    }
+}
+
+fn parse_xlsx_preview_file_with_options(
+    path: &str,
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+) -> Result<(ParsedImportFile, Vec<String>), String> {
+    // Read worksheet XML directly so preview can stop after the requested rows instead of
+    // materializing the workbook's complete cell range.
+    let file = File::open(path).map_err(|error| error.to_string())?;
+    let mut zip = zip::ZipArchive::new(file).map_err(|error| error.to_string())?;
+    let workbook_xml = read_xlsx_zip_text(&mut zip, "xl/workbook.xml")?;
+    let rels_xml = read_xlsx_zip_text(&mut zip, "xl/_rels/workbook.xml.rels").unwrap_or_default();
+    let sheet_refs = xlsx_workbook_sheet_refs(&workbook_xml);
+    let sheets = sheet_refs.iter().map(|(name, _)| name.clone()).collect::<Vec<_>>();
+    let sheet_name = if let Some(name) = options.sheet_name.as_ref().filter(|name| !name.trim().is_empty()) {
+        if !sheets.iter().any(|sheet| sheet == name) {
+            return Err(format!("Workbook sheet not found: {name}"));
+        }
+        name.clone()
+    } else if let Some(index) = options.sheet_index {
+        sheets.get(index).cloned().ok_or_else(|| format!("Workbook sheet index out of range: {index}"))?
+    } else {
+        sheets.first().cloned().ok_or_else(|| "Workbook has no sheets".to_string())?
+    };
+    let sheet_path = xlsx_sheet_path_for_name(&workbook_xml, &rels_xml, &sheet_name)
+        .ok_or_else(|| format!("Workbook sheet not found: {sheet_name}"))?;
+    let styles_xml = read_xlsx_zip_text(&mut zip, "xl/styles.xml").unwrap_or_default();
+    let styles = parse_xlsx_styles(&styles_xml);
+    let date_1904 = xlsx_workbook_uses_1904_date_system(&workbook_xml);
+    let row_range = effective_import_row_range(options)?;
+    let preview_limit = preview_limit.max(1);
+    let preview_last_row = row_range.data_start_row.saturating_add(preview_limit.saturating_sub(1));
+    let requested_last_row = row_range.last_data_row.map_or(preview_last_row, |last| last.min(preview_last_row));
+    let max_relative_row = requested_last_row.max(row_range.title_row.unwrap_or_default());
+
+    let mut dimension = None;
+    let mut raw_cells = HashMap::<(usize, usize), XlsxPreviewRawCell>::new();
+    let mut observed_min_row = usize::MAX;
+    let mut observed_min_column = usize::MAX;
+    let mut observed_max_column = 0usize;
+    let mut observed_max_row = 0usize;
+    {
+        let sheet = zip.by_name(&sheet_path).map_err(|error| error.to_string())?;
+        let mut reader = XmlReader::from_reader(BufReader::new(sheet));
+        reader.config_mut().trim_text(false);
+        let mut buf = Vec::new();
+        let mut current_position = None;
+        let mut current_cell = XlsxPreviewRawCell::default();
+        let mut current_row = 0usize;
+        let mut current_column = 0usize;
+        let mut in_value = false;
+        let mut in_inline_text = false;
+        let mut inline_phonetic_depth = 0usize;
+        loop {
+            match reader.read_event_into(&mut buf) {
+                Ok(Event::Start(element)) | Ok(Event::Empty(element))
+                    if xml_local_name_eq(element.name().as_ref(), b"dimension") =>
+                {
+                    dimension = xml_attr_value(&reader, &element, b"ref").as_deref().and_then(xlsx_dimension_bounds);
+                }
+                Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"row") => {
+                    current_row = xml_attr_value(&reader, &element, b"r")
+                        .and_then(|value| value.parse::<usize>().ok())
+                        .filter(|row| *row > 0)
+                        .unwrap_or_else(|| current_row.saturating_add(1).max(1));
+                    current_column = 0;
+                    if observed_min_row != usize::MAX {
+                        let max_absolute_row = observed_min_row.saturating_add(max_relative_row.saturating_sub(1));
+                        if current_row > max_absolute_row {
+                            break;
+                        }
+                    }
+                    observed_max_row = observed_max_row.max(current_row);
+                }
+                Ok(Event::Empty(element)) if xml_local_name_eq(element.name().as_ref(), b"c") => {
+                    let position = xml_attr_value(&reader, &element, b"r")
+                        .as_deref()
+                        .and_then(xlsx_cell_ref_position)
+                        .unwrap_or_else(|| (current_row.max(1), current_column.saturating_add(1).max(1)));
+                    current_row = position.0;
+                    current_column = position.1;
+                    observed_min_row = observed_min_row.min(position.0);
+                    observed_min_column = observed_min_column.min(position.1);
+                    observed_max_row = observed_max_row.max(position.0);
+                    observed_max_column = observed_max_column.max(position.1);
+                }
+                Ok(Event::Empty(element)) if xml_local_name_eq(element.name().as_ref(), b"c") => continue,
+                Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"c") => {
+                    let position = xml_attr_value(&reader, &element, b"r")
+                        .as_deref()
+                        .and_then(xlsx_cell_ref_position)
+                        .unwrap_or_else(|| (current_row.max(1), current_column.saturating_add(1).max(1)));
+                    current_row = position.0;
+                    current_column = position.1;
+                    current_position = Some(position);
+                    current_cell = XlsxPreviewRawCell {
+                        cell_type: xml_attr_value(&reader, &element, b"t"),
+                        style_id: xml_attr_value(&reader, &element, b"s").and_then(|value| value.parse::<usize>().ok()),
+                        ..XlsxPreviewRawCell::default()
+                    };
+                }
+                Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"v") => {
+                    in_value = true;
+                }
+                Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"t") => {
+                    in_inline_text = inline_phonetic_depth == 0;
+                }
+                Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"rPh") => {
+                    inline_phonetic_depth = inline_phonetic_depth.saturating_add(1);
+                }
+                Ok(Event::Text(text)) if in_value => {
+                    current_cell.value.push_str(&text.unescape().map_err(|error| error.to_string())?);
+                }
+                Ok(Event::Text(text)) if in_inline_text => {
+                    current_cell.inline_value.push_str(&text.unescape().map_err(|error| error.to_string())?);
+                }
+                Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"v") => {
+                    in_value = false;
+                }
+                Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"t") => {
+                    in_inline_text = false;
+                }
+                Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"rPh") => {
+                    inline_phonetic_depth = inline_phonetic_depth.saturating_sub(1);
+                }
+                Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"c") => {
+                    if let Some((row, column)) = current_position.take() {
+                        observed_min_row = observed_min_row.min(row);
+                        observed_min_column = observed_min_column.min(column);
+                        observed_max_column = observed_max_column.max(column);
+                        observed_max_row = observed_max_row.max(row);
+                        let relative_row = row.saturating_sub(observed_min_row).saturating_add(1);
+                        if relative_row == row_range.title_row.unwrap_or_default()
+                            || (relative_row >= row_range.data_start_row && relative_row <= requested_last_row)
+                        {
+                            raw_cells.insert((row, column), std::mem::take(&mut current_cell));
+                        }
+                    }
+                    inline_phonetic_depth = 0;
+                    in_inline_text = false;
+                }
+                Ok(Event::Eof) => break,
+                Err(error) => return Err(error.to_string()),
+                _ => {}
+            }
+            buf.clear();
+        }
+    }
+
+    let needed_shared_strings = raw_cells
+        .values()
+        .filter(|cell| cell.cell_type.as_deref() == Some("s"))
+        .filter_map(|cell| cell.value.parse::<usize>().ok())
+        .collect::<HashSet<_>>();
+    let shared_strings = read_xlsx_shared_strings(&mut zip, &needed_shared_strings)?;
+    if observed_min_row == usize::MAX || observed_min_column == usize::MAX {
+        return Err("Import file has no data rows in the selected row range".to_string());
+    }
+    let start_row = observed_min_row;
+    let start_column = observed_min_column;
+    let observed_end_column = observed_max_column.max(start_column);
+    let observed_column_count = observed_end_column.saturating_sub(start_column).saturating_add(1);
+    let preview_row_count = requested_last_row
+        .saturating_sub(row_range.data_start_row)
+        .saturating_add(1)
+        .saturating_add(usize::from(row_range.title_row.is_some()));
+    if observed_column_count.saturating_mul(preview_row_count) > MAX_FAST_PREVIEW_CELLS {
+        return Err(format!(
+            "Excel preview grid is too large: {} columns across {} preview rows exceed the {} cell limit",
+            observed_column_count, preview_row_count, MAX_FAST_PREVIEW_CELLS
+        ));
+    }
+    let dimension_end_column = dimension
+        .filter(|((dimension_start_row, dimension_start_column), _)| {
+            *dimension_start_row == start_row && *dimension_start_column == start_column
+        })
+        .map(|(_, (_, end_column))| end_column)
+        .filter(|end_column| {
+            end_column.saturating_sub(start_column).saturating_add(1).saturating_mul(preview_row_count)
+                <= MAX_FAST_PREVIEW_CELLS
+        });
+    let end_column = dimension_end_column.unwrap_or(observed_end_column).max(observed_end_column);
+    let column_count = end_column.saturating_sub(start_column).saturating_add(1);
+    let mut columns = if let Some(title_row) = row_range.title_row {
+        let absolute_title_row = start_row.saturating_add(title_row.saturating_sub(1));
+        (0..column_count)
+            .map(|index| {
+                let column = start_column + index;
+                let value = raw_cells
+                    .get(&(absolute_title_row, column))
+                    .map(|cell| xlsx_preview_cell_value(cell, &shared_strings, &styles, date_1904))
+                    .unwrap_or(serde_json::Value::Null);
+                normalize_header(&xlsx_preview_cell_label(&value), index)
+            })
+            .collect::<Vec<_>>()
+    } else {
+        Vec::new()
+    };
+    if columns.is_empty() {
+        columns = (0..column_count).map(|index| format!("column_{}", index + 1)).collect();
+    }
+    if columns.is_empty() {
+        return Err("Import file has no columns in the selected row range".to_string());
+    }
+
+    let observed_end_relative = observed_max_row.saturating_sub(start_row).saturating_add(1);
+    let last_preview_row = requested_last_row.min(observed_end_relative);
+    if last_preview_row < row_range.data_start_row {
+        return Err("Import file has no data rows in the selected row range".to_string());
+    }
+    let rows = (row_range.data_start_row..=last_preview_row)
+        .map(|relative_row| {
+            let absolute_row = start_row + relative_row - 1;
+            (0..columns.len())
+                .map(|index| {
+                    raw_cells
+                        .get(&(absolute_row, start_column + index))
+                        .map(|cell| xlsx_preview_cell_value(cell, &shared_strings, &styles, date_1904))
+                        .unwrap_or(serde_json::Value::Null)
+                })
+                .collect::<Vec<_>>()
+        })
+        .collect::<Vec<_>>();
+    if rows.is_empty() {
+        return Err("Import file has no data rows in the selected row range".to_string());
+    }
+    Ok((ParsedImportFile { columns, total_rows: rows.len(), rows, effective_encoding: None }, sheets))
+}
+
 fn xlsx_cell_styles(
     path: &str,
     sheet_name: &str,
@@ -1219,6 +2062,31 @@ fn is_legacy_xls_path(path: &str) -> bool {
         .is_some_and(|extension| extension.eq_ignore_ascii_case("xls"))
 }
 
+fn xlsx_style_selection_columns<T, Label>(range: &Range<T>, row_range: ImportRowRange, cell_label: Label) -> Vec<String>
+where
+    T: CellType,
+    Label: Fn(&T, Option<XlsxTemporalKind>) -> String,
+{
+    for (index, source_row) in range.rows().enumerate() {
+        let row_number = index + 1;
+        if row_range.title_row == Some(row_number) {
+            return source_row
+                .iter()
+                .enumerate()
+                .map(|(index, cell)| normalize_header(&cell_label(cell, None), index))
+                .collect();
+        }
+        let row_is_within_range = match row_range.last_data_row {
+            Some(last) => row_number <= last,
+            None => true,
+        };
+        if row_number >= row_range.data_start_row && row_is_within_range {
+            return (0..source_row.len()).map(|index| format!("column_{}", index + 1)).collect();
+        }
+    }
+    Vec::new()
+}
+
 pub fn parse_xlsx_file_with_options(
     path: &str,
     options: &TableImportParseOptions,
@@ -1245,38 +2113,498 @@ fn parse_xlsx_file_with_options_and_text_columns(
     } else {
         sheet_names.first().cloned().ok_or_else(|| "Workbook has no sheets".to_string())?
     };
-    let range = workbook.worksheet_range(&sheet_name).map_err(|e| e.to_string())?;
-    let (range_start_row, range_start_column) =
-        range.start().map(|(row, column)| (row as usize, column as usize)).unwrap_or_default();
-    let row_range = effective_import_row_range(options)?;
-    let mut style_selection_columns = Vec::new();
-    for (index, source_row) in range.rows().enumerate() {
-        let row_number = index + 1;
-        if row_range.title_row == Some(row_number) {
-            style_selection_columns = source_row
-                .iter()
-                .enumerate()
-                .map(|(index, cell)| normalize_header(&xlsx_cell_label(cell), index))
-                .collect();
-            break;
-        }
-        let row_is_within_range = match row_range.last_data_row {
-            Some(last) => row_number <= last,
-            None => true,
-        };
-        if row_number >= row_range.data_start_row && row_is_within_range {
-            style_selection_columns = (0..source_row.len()).map(|index| format!("column_{}", index + 1)).collect();
-            break;
-        }
+    let extension = Path::new(path).extension().and_then(|extension| extension.to_str()).unwrap_or_default();
+    let legacy_xls = is_legacy_xls_path(path);
+    if extension.eq_ignore_ascii_case("xlsx") || extension.eq_ignore_ascii_case("xlsm") {
+        let range = workbook.worksheet_range_ref(&sheet_name).map_err(|e| e.to_string())?;
+        let row_range = effective_import_row_range(options)?;
+        let style_selection_columns =
+            xlsx_style_selection_columns(&range, row_range, xlsx_cell_ref_label_with_temporal_kind);
+        let text_worksheet_columns = style_selection_columns
+            .iter()
+            .enumerate()
+            .filter_map(|(index, column)| {
+                text_source_columns
+                    .contains(column)
+                    .then_some(range.start().map_or(index + 1, |(_, start)| start as usize + index + 1))
+            })
+            .collect::<HashSet<_>>();
+        let cell_styles =
+            if legacy_xls { HashMap::new() } else { xlsx_cell_styles(path, &sheet_name, &text_worksheet_columns)? };
+        return parse_xlsx_range(
+            &range,
+            options,
+            preview_limit,
+            &cell_styles,
+            text_source_columns,
+            legacy_xls,
+            xlsx_cell_ref_label_with_temporal_kind,
+            xlsx_cell_ref_value_with_temporal_kind,
+            xlsx_cell_ref_text_value,
+            xlsx_cell_ref_is_numeric,
+        );
     }
+
+    let range = workbook.worksheet_range(&sheet_name).map_err(|e| e.to_string())?;
+    let row_range = effective_import_row_range(options)?;
+    let style_selection_columns = xlsx_style_selection_columns(&range, row_range, xlsx_cell_label_with_temporal_kind);
     let text_worksheet_columns = style_selection_columns
         .iter()
         .enumerate()
-        .filter_map(|(index, column)| text_source_columns.contains(column).then_some(range_start_column + index + 1))
+        .filter_map(|(index, column)| {
+            text_source_columns
+                .contains(column)
+                .then_some(range.start().map_or(index + 1, |(_, start)| start as usize + index + 1))
+        })
         .collect::<HashSet<_>>();
-    let legacy_xls = is_legacy_xls_path(path);
     let cell_styles =
         if legacy_xls { HashMap::new() } else { xlsx_cell_styles(path, &sheet_name, &text_worksheet_columns)? };
+    parse_xlsx_range(
+        &range,
+        options,
+        preview_limit,
+        &cell_styles,
+        text_source_columns,
+        legacy_xls,
+        xlsx_cell_label_with_temporal_kind,
+        xlsx_cell_value_with_temporal_kind,
+        xlsx_cell_text_value,
+        xlsx_cell_is_numeric,
+    )
+}
+
+#[derive(Debug)]
+enum XlsxStreamMessage {
+    Header(Vec<String>),
+    Rows(Vec<Vec<serde_json::Value>>),
+    Progress(u64),
+    Done,
+}
+
+fn xlsx_stream_cell_value(
+    cell: &XlsxPreviewRawCell,
+    shared_strings: &mut XlsxSharedStrings,
+    styles: &[XlsxCellStyle],
+    date_1904: bool,
+    format_as_text: bool,
+) -> Result<serde_json::Value, String> {
+    if format_as_text && cell.cell_type.as_deref().unwrap_or_default().is_empty() {
+        if let Ok(number) = cell.value.trim().parse::<f64>() {
+            let style = cell.style_id.and_then(|style| styles.get(style));
+            if style.and_then(|style| style.temporal_kind).is_none() {
+                return Ok(serde_json::Value::String(xlsx_numeric_display_text(number, style)));
+            }
+        }
+    }
+    if cell.cell_type.as_deref() != Some("s") {
+        return Ok(xlsx_preview_cell_value(cell, &HashMap::new(), styles, date_1904));
+    }
+    let Some(index) = cell.value.parse::<usize>().ok() else {
+        return Ok(serde_json::Value::Null);
+    };
+    Ok(shared_strings.get(index)?.map_or(serde_json::Value::Null, |value| csv_value(&value)))
+}
+
+fn xlsx_cell_ref_text_value(cell: &DataRef<'_>, style: Option<&XlsxCellStyle>) -> Option<String> {
+    if style.and_then(|style| style.temporal_kind).is_some() {
+        return None;
+    }
+    match cell {
+        DataRef::Float(value) if value.is_finite() => Some(xlsx_numeric_display_text(*value, style)),
+        DataRef::Int(value) => Some(xlsx_numeric_display_text(*value as f64, style)),
+        _ => None,
+    }
+}
+
+fn xlsx_cell_ref_is_numeric(cell: &DataRef<'_>) -> bool {
+    matches!(cell, DataRef::Float(_) | DataRef::Int(_))
+}
+
+fn xlsx_cell_is_numeric(cell: &Data) -> bool {
+    matches!(cell, Data::Float(_) | Data::Int(_))
+}
+
+struct XlsxStreamRowsState {
+    sender: tokio::sync::mpsc::Sender<Result<XlsxStreamMessage, String>>,
+    row_range: ImportRowRange,
+    dimension: Option<((usize, usize), (usize, usize))>,
+    start_row: Option<usize>,
+    start_column: usize,
+    declared_column_count: Option<usize>,
+    columns: Vec<String>,
+    header_sent: bool,
+    pending_rows: Vec<Vec<serde_json::Value>>,
+    rows_seen: usize,
+    current_row: Option<usize>,
+    current_values: Vec<serde_json::Value>,
+    batch_size: usize,
+}
+
+impl XlsxStreamRowsState {
+    fn new(
+        sender: tokio::sync::mpsc::Sender<Result<XlsxStreamMessage, String>>,
+        row_range: ImportRowRange,
+        dimension: Option<((usize, usize), (usize, usize))>,
+        expected_columns: Option<Vec<String>>,
+        batch_size: usize,
+    ) -> Self {
+        let batch_size = batch_size.max(1);
+        Self {
+            sender,
+            row_range,
+            dimension,
+            start_row: None,
+            start_column: 0,
+            declared_column_count: None,
+            columns: expected_columns.unwrap_or_default(),
+            header_sent: false,
+            pending_rows: Vec::with_capacity(batch_size),
+            rows_seen: 0,
+            current_row: None,
+            current_values: Vec::new(),
+            batch_size,
+        }
+    }
+
+    fn initialize_range(&mut self, first_row: usize, first_column: usize) {
+        if self.start_row.is_some() {
+            return;
+        }
+        let expected_column_count = (!self.columns.is_empty()).then_some(self.columns.len());
+        let dimension = self.dimension.filter(|((start_row, start_column), (end_row, end_column))| {
+            let column_count = end_column.saturating_sub(*start_column).saturating_add(1);
+            let row_count = end_row.saturating_sub(*start_row).saturating_add(1);
+            *start_row == first_row
+                && *start_column == first_column
+                && column_count <= MAX_FAST_PREVIEW_CELLS
+                && expected_column_count
+                    .map_or(column_count.saturating_mul(row_count) <= MAX_FAST_PREVIEW_CELLS, |expected| {
+                        expected == column_count
+                    })
+        });
+        self.start_row = Some(first_row);
+        self.start_column = first_column;
+        self.declared_column_count = dimension
+            .map(|((_, start_column), (_, end_column))| end_column.saturating_sub(start_column).saturating_add(1));
+    }
+
+    fn selected_range_finished(&self, absolute_row: usize) -> bool {
+        let Some(start_row) = self.start_row else {
+            return false;
+        };
+        self.row_range.last_data_row.is_some_and(|last| absolute_row > start_row.saturating_add(last.saturating_sub(1)))
+    }
+
+    fn is_text_source_column(
+        &mut self,
+        absolute_row: usize,
+        absolute_column: usize,
+        text_source_columns: &HashSet<String>,
+    ) -> bool {
+        self.initialize_range(absolute_row, absolute_column);
+        absolute_column
+            .checked_sub(self.start_column)
+            .and_then(|offset| self.columns.get(offset))
+            .is_some_and(|column| text_source_columns.contains(column))
+    }
+
+    fn push_cell(
+        &mut self,
+        absolute_row: usize,
+        absolute_column: usize,
+        value: serde_json::Value,
+        progress: u64,
+    ) -> Result<(), String> {
+        self.initialize_range(absolute_row, absolute_column);
+        if self.current_row != Some(absolute_row) {
+            self.flush_current_row(progress)?;
+            self.current_row = Some(absolute_row);
+        }
+        let column_offset = absolute_column.checked_sub(self.start_column).ok_or_else(|| {
+            format!("Excel row {absolute_row} contains a cell before the detected import range start column")
+        })?;
+        if column_offset >= MAX_FAST_PREVIEW_CELLS {
+            return Err(format!("Excel import column {} exceeds the safety limit", column_offset + 1));
+        }
+        if column_offset >= self.current_values.len() {
+            self.current_values.resize(column_offset + 1, serde_json::Value::Null);
+        }
+        self.current_values[column_offset] = value;
+        Ok(())
+    }
+
+    fn flush_current_row(&mut self, progress: u64) -> Result<(), String> {
+        let Some(absolute_row) = self.current_row.take() else {
+            return Ok(());
+        };
+        let values = std::mem::take(&mut self.current_values);
+        self.flush_row(absolute_row, values, progress)
+    }
+
+    fn flush_row(
+        &mut self,
+        absolute_row: usize,
+        mut values: Vec<serde_json::Value>,
+        progress: u64,
+    ) -> Result<(), String> {
+        let relative_row = absolute_row.saturating_sub(self.start_row.unwrap_or(absolute_row)).saturating_add(1);
+        if self.row_range.title_row == Some(relative_row) {
+            if self.columns.is_empty() {
+                let column_count = self.declared_column_count.unwrap_or(values.len()).max(values.len());
+                values.resize(column_count, serde_json::Value::Null);
+                self.columns = values
+                    .iter()
+                    .enumerate()
+                    .map(|(index, value)| normalize_header(&xlsx_preview_cell_label(value), index))
+                    .collect();
+            }
+            return Ok(());
+        }
+        if relative_row < self.row_range.data_start_row
+            || self.row_range.last_data_row.is_some_and(|last| relative_row > last)
+        {
+            return Ok(());
+        }
+        if self.columns.is_empty() {
+            let column_count = self.declared_column_count.unwrap_or(values.len()).max(values.len());
+            self.columns = (0..column_count).map(|index| format!("column_{}", index + 1)).collect();
+        }
+        if !self.header_sent {
+            self.sender
+                .blocking_send(Ok(XlsxStreamMessage::Header(self.columns.clone())))
+                .map_err(|_| "Excel import consumer closed before the stream started".to_string())?;
+            self.header_sent = true;
+        }
+        if values.len() > self.columns.len() && values[self.columns.len()..].iter().any(|value| !value.is_null()) {
+            return Err(format!(
+                "Excel row {absolute_row} contains data beyond the {} columns confirmed by the preview",
+                self.columns.len()
+            ));
+        }
+        values.resize(self.columns.len(), serde_json::Value::Null);
+        values.truncate(self.columns.len());
+        self.pending_rows.push(values);
+        self.rows_seen = self.rows_seen.saturating_add(1);
+        if self.pending_rows.len() >= self.batch_size {
+            self.emit_rows(progress)?;
+        }
+        Ok(())
+    }
+
+    fn emit_rows(&mut self, progress: u64) -> Result<(), String> {
+        if self.pending_rows.is_empty() {
+            return Ok(());
+        }
+        self.sender
+            .blocking_send(Ok(XlsxStreamMessage::Rows(std::mem::take(&mut self.pending_rows))))
+            .map_err(|_| "Excel import consumer closed before the stream finished".to_string())?;
+        self.sender
+            .blocking_send(Ok(XlsxStreamMessage::Progress(progress)))
+            .map_err(|_| "Excel import consumer closed before the stream finished".to_string())?;
+        self.pending_rows = Vec::with_capacity(self.batch_size);
+        Ok(())
+    }
+
+    fn finish(mut self, progress: u64) -> Result<(), String> {
+        self.flush_current_row(progress)?;
+        self.emit_rows(progress)?;
+        if !self.header_sent || self.rows_seen == 0 {
+            return Err("Import file has no data rows in the selected row range".to_string());
+        }
+        self.sender
+            .blocking_send(Ok(XlsxStreamMessage::Done))
+            .map_err(|_| "Excel import consumer closed before the stream finished".to_string())
+    }
+}
+
+fn stream_xlsx_rows_to_channel(
+    path: &str,
+    options: &TableImportParseOptions,
+    batch_size: usize,
+    expected_columns: Option<Vec<String>>,
+    text_source_columns: HashSet<String>,
+    scan_full_worksheet: bool,
+    sender: tokio::sync::mpsc::Sender<Result<XlsxStreamMessage, String>>,
+) -> Result<(), String> {
+    // This producer runs on a blocking thread and communicates in bounded batches. The small
+    // channel capacity applies backpressure when database writes are slower than XML parsing.
+    let total_bytes = std::fs::metadata(path).map(|metadata| metadata.len()).unwrap_or_default();
+    let mut zip = zip::ZipArchive::new(File::open(path).map_err(|error| error.to_string())?)
+        .map_err(|error| error.to_string())?;
+    let workbook_xml = read_xlsx_zip_text(&mut zip, "xl/workbook.xml")?;
+    let rels_xml = read_xlsx_zip_text(&mut zip, "xl/_rels/workbook.xml.rels").unwrap_or_default();
+    let sheet_refs = xlsx_workbook_sheet_refs(&workbook_xml);
+    let sheet_names = sheet_refs.iter().map(|(name, _)| name.clone()).collect::<Vec<_>>();
+    let sheet_name = if let Some(name) = options.sheet_name.as_ref().filter(|name| !name.trim().is_empty()) {
+        if !sheet_names.iter().any(|sheet| sheet == name) {
+            return Err(format!("Workbook sheet not found: {name}"));
+        }
+        name.clone()
+    } else if let Some(index) = options.sheet_index {
+        sheet_names.get(index).cloned().ok_or_else(|| format!("Workbook sheet index out of range: {index}"))?
+    } else {
+        sheet_names.first().cloned().ok_or_else(|| "Workbook has no sheets".to_string())?
+    };
+    let styles_xml = read_xlsx_zip_text(&mut zip, "xl/styles.xml").unwrap_or_default();
+    let styles = parse_xlsx_styles(&styles_xml);
+    let date_1904 = xlsx_workbook_uses_1904_date_system(&workbook_xml);
+    let sheet_path = xlsx_sheet_path_for_name(&workbook_xml, &rels_xml, &sheet_name)
+        .ok_or_else(|| format!("Workbook sheet not found: {sheet_name}"))?;
+    let mut shared_strings = open_xlsx_shared_strings(&mut zip, MAX_IN_MEMORY_XLSX_SHARED_STRINGS_BYTES)?;
+    let row_range = effective_import_row_range(options)?;
+    let sheet = zip.by_name(&sheet_path).map_err(|error| error.to_string())?;
+    let uncompressed_sheet_bytes = sheet.size().max(1);
+    let mut reader = XmlReader::from_reader(BufReader::new(sheet));
+    reader.config_mut().trim_text(false);
+    let mut rows = XlsxStreamRowsState::new(sender, row_range, None, expected_columns, batch_size);
+    let mut buffer = Vec::new();
+    let mut current_row = 0usize;
+    let mut current_column = 0usize;
+    let mut current_position = None;
+    let mut current_cell = XlsxPreviewRawCell::default();
+    let mut in_value = false;
+    let mut in_inline_text = false;
+    let mut inline_phonetic_depth = 0usize;
+    loop {
+        // Convert the uncompressed worksheet offset into an approximate archive-byte offset so
+        // progress remains monotonic without scanning the ZIP twice.
+        let progress = reader
+            .buffer_position()
+            .saturating_mul(total_bytes)
+            .checked_div(uncompressed_sheet_bytes)
+            .unwrap_or_default()
+            .min(total_bytes);
+        match reader.read_event_into(&mut buffer) {
+            Ok(Event::Start(element)) | Ok(Event::Empty(element))
+                if xml_local_name_eq(element.name().as_ref(), b"dimension") =>
+            {
+                rows.dimension = xml_attr_value(&reader, &element, b"ref").as_deref().and_then(xlsx_dimension_bounds);
+            }
+            Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"row") => {
+                current_row = xml_attr_value(&reader, &element, b"r")
+                    .and_then(|value| value.parse::<usize>().ok())
+                    .filter(|row| *row > 0)
+                    .unwrap_or_else(|| current_row.saturating_add(1).max(1));
+                current_column = 0;
+                if !scan_full_worksheet && rows.selected_range_finished(current_row) {
+                    break;
+                }
+            }
+            Ok(Event::Empty(element)) if xml_local_name_eq(element.name().as_ref(), b"c") => {
+                let position = xml_attr_value(&reader, &element, b"r")
+                    .as_deref()
+                    .and_then(xlsx_cell_ref_position)
+                    .unwrap_or_else(|| (current_row.max(1), current_column.saturating_add(1).max(1)));
+                current_row = position.0;
+                current_column = position.1;
+                rows.push_cell(position.0, position.1, serde_json::Value::Null, progress)?;
+            }
+            Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"c") => {
+                let position = xml_attr_value(&reader, &element, b"r")
+                    .as_deref()
+                    .and_then(xlsx_cell_ref_position)
+                    .unwrap_or_else(|| (current_row.max(1), current_column.saturating_add(1).max(1)));
+                current_row = position.0;
+                current_column = position.1;
+                current_position = Some(position);
+                current_cell = XlsxPreviewRawCell {
+                    cell_type: xml_attr_value(&reader, &element, b"t"),
+                    style_id: xml_attr_value(&reader, &element, b"s").and_then(|value| value.parse::<usize>().ok()),
+                    ..XlsxPreviewRawCell::default()
+                };
+            }
+            Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"v") => in_value = true,
+            Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"t") => {
+                in_inline_text = inline_phonetic_depth == 0;
+            }
+            Ok(Event::Start(element)) if xml_local_name_eq(element.name().as_ref(), b"rPh") => {
+                inline_phonetic_depth = inline_phonetic_depth.saturating_add(1);
+            }
+            Ok(Event::Text(text)) if in_value => {
+                current_cell.value.push_str(&text.unescape().map_err(|error| error.to_string())?);
+            }
+            Ok(Event::Text(text)) if in_inline_text => {
+                current_cell.inline_value.push_str(&text.unescape().map_err(|error| error.to_string())?);
+            }
+            Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"v") => in_value = false,
+            Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"t") => in_inline_text = false,
+            Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"rPh") => {
+                inline_phonetic_depth = inline_phonetic_depth.saturating_sub(1);
+            }
+            Ok(Event::End(element)) if xml_local_name_eq(element.name().as_ref(), b"c") => {
+                if let Some((row, column)) = current_position.take() {
+                    let format_as_text = rows.is_text_source_column(row, column, &text_source_columns);
+                    let value =
+                        xlsx_stream_cell_value(&current_cell, &mut shared_strings, &styles, date_1904, format_as_text)?;
+                    rows.push_cell(row, column, value, progress)?;
+                    current_cell = XlsxPreviewRawCell::default();
+                }
+                inline_phonetic_depth = 0;
+                in_inline_text = false;
+            }
+            Ok(Event::Eof) => break,
+            Err(error) => return Err(error.to_string()),
+            _ => {}
+        }
+        buffer.clear();
+    }
+    rows.finish(total_bytes)
+}
+
+async fn validate_xlsx_worksheet_for_import(
+    path: String,
+    options: TableImportParseOptions,
+    expected_columns: Option<Vec<String>>,
+    text_source_columns: HashSet<String>,
+) -> Result<(), String> {
+    // Drain bounded row batches without writing. Full-sheet mode keeps parsing through the
+    // worksheet EOF even when the selected import range ends earlier.
+    let (sender, mut receiver) = tokio::sync::mpsc::channel::<Result<XlsxStreamMessage, String>>(2);
+    let validation = tokio::task::spawn_blocking(move || {
+        stream_xlsx_rows_to_channel(
+            &path,
+            &options,
+            DEFAULT_BATCH_SIZE,
+            expected_columns,
+            text_source_columns,
+            true,
+            sender,
+        )
+    });
+
+    while let Some(message) = receiver.recv().await {
+        if let Err(error) = message {
+            drop(receiver);
+            let _ = validation.await;
+            return Err(error);
+        }
+    }
+
+    validation.await.map_err(|error| error.to_string())?
+}
+
+fn parse_xlsx_range<T, Label, Value, TextValue, IsNumeric>(
+    range: &Range<T>,
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+    cell_styles: &HashMap<(usize, usize), XlsxCellStyle>,
+    text_source_columns: &HashSet<String>,
+    legacy_xls: bool,
+    cell_label: Label,
+    cell_value: Value,
+    cell_text_value: TextValue,
+    is_numeric: IsNumeric,
+) -> Result<ParsedImportFile, String>
+where
+    T: CellType,
+    Label: Fn(&T, Option<XlsxTemporalKind>) -> String,
+    Value: Fn(&T, Option<XlsxTemporalKind>) -> serde_json::Value,
+    TextValue: Fn(&T, Option<&XlsxCellStyle>) -> Option<String>,
+    IsNumeric: Fn(&T) -> bool,
+{
+    let (range_start_row, range_start_column) =
+        range.start().map(|(row, column)| (row as usize, column as usize)).unwrap_or_default();
+    let row_range = effective_import_row_range(options)?;
     let mut columns = Vec::new();
     let mut rows = Vec::new();
     let mut total_rows = 0;
@@ -1290,10 +2618,7 @@ fn parse_xlsx_file_with_options_and_text_columns(
                     // Calamine rows are relative to the used range, while XLSX style coordinates are worksheet-absolute.
                     let cell_position = (range_start_row + row_number, range_start_column + index + 1);
                     normalize_header(
-                        &xlsx_cell_label_with_temporal_kind(
-                            cell,
-                            cell_styles.get(&cell_position).and_then(|style| style.temporal_kind),
-                        ),
+                        &cell_label(cell, cell_styles.get(&cell_position).and_then(|style| style.temporal_kind)),
                         index,
                     )
                 })
@@ -1321,16 +2646,16 @@ fn parse_xlsx_file_with_options_and_text_columns(
                 .get(index)
                 .map(|cell| {
                     if text_source_columns.contains(column) {
-                        if legacy_xls && matches!(cell, Data::Float(_) | Data::Int(_)) {
+                        if legacy_xls && is_numeric(cell) {
                             return Err(format!(
                                 "Legacy .xls files cannot preserve numeric display formatting for text target column '{column}'. Save the workbook as .xlsx or map this source column to a numeric target."
                             ));
                         }
-                        if let Some(text) = xlsx_cell_text_value(cell, style) {
+                        if let Some(text) = cell_text_value(cell, style) {
                             return Ok(serde_json::Value::String(text));
                         }
                     }
-                    Ok(xlsx_cell_value_with_temporal_kind(cell, style.and_then(|style| style.temporal_kind)))
+                    Ok(cell_value(cell, style.and_then(|style| style.temporal_kind)))
                 })
                 .transpose()?
                 .unwrap_or(serde_json::Value::Null);
@@ -1356,12 +2681,18 @@ fn ensure_non_streaming_file_size(path: &str, format: TableImportSourceFormat) -
         return Ok(());
     }
     let metadata = std::fs::metadata(path).map_err(|e| e.to_string())?;
-    if metadata.len() > MAX_NON_STREAMING_IMPORT_BYTES {
+    let extension = Path::new(path).extension().and_then(|extension| extension.to_str()).unwrap_or_default();
+    let max_bytes = if format == TableImportSourceFormat::Excel && extension.eq_ignore_ascii_case("xls") {
+        MAX_LEGACY_XLS_IMPORT_BYTES
+    } else {
+        MAX_NON_STREAMING_IMPORT_BYTES
+    };
+    if metadata.len() > max_bytes {
         return Err(format!(
             "File too large for {} import: {} bytes (max {} bytes)",
             format.label(),
             metadata.len(),
-            MAX_NON_STREAMING_IMPORT_BYTES
+            max_bytes
         ));
     }
     Ok(())
@@ -1411,6 +2742,47 @@ async fn parse_import_file_with_options_and_text_columns(
     }
 }
 
+async fn parse_import_preview_file_with_options(
+    path: &str,
+    format: TableImportSourceFormat,
+    options: &TableImportParseOptions,
+    preview_limit: usize,
+) -> Result<(ParsedImportFile, bool, Vec<String>), String> {
+    if format.is_delimited() {
+        let path = path.to_string();
+        let options = options.clone();
+        let parsed = tokio::task::spawn_blocking(move || {
+            parse_delimited_preview_file_with_options(&path, format, &options, preview_limit)
+        })
+        .await
+        .map_err(|e| e.to_string())??;
+        return Ok((parsed, false, Vec::new()));
+    }
+
+    ensure_non_streaming_file_size(path, format)?;
+    let extension = Path::new(path).extension().and_then(|extension| extension.to_str()).unwrap_or_default();
+    if format == TableImportSourceFormat::Excel
+        && (extension.eq_ignore_ascii_case("xlsx") || extension.eq_ignore_ascii_case("xlsm"))
+    {
+        let path = path.to_string();
+        let options = options.clone();
+        let (parsed, sheets) =
+            tokio::task::spawn_blocking(move || parse_xlsx_preview_file_with_options(&path, &options, preview_limit))
+                .await
+                .map_err(|e| e.to_string())??;
+        return Ok((parsed, false, sheets));
+    }
+
+    let parsed = parse_import_file_with_options(path, Some(format), options, preview_limit).await?;
+    let sheets = if format == TableImportSourceFormat::Excel {
+        let path = path.to_string();
+        tokio::task::spawn_blocking(move || xlsx_sheet_names(&path)).await.map_err(|e| e.to_string())??
+    } else {
+        Vec::new()
+    };
+    Ok((parsed, true, sheets))
+}
+
 pub async fn parse_import_file(path: &str, preview_limit: usize) -> Result<ParsedImportFile, String> {
     parse_import_file_with_options(path, None, &TableImportParseOptions::default(), preview_limit).await
 }
@@ -1456,6 +2828,26 @@ fn mapping_indexes_with_mappings<'a>(
     Ok(mapped)
 }
 
+fn compile_import_plan(
+    columns: &[String],
+    mappings: &[TableImportColumnMapping],
+    target_column_types: &[(String, String)],
+) -> Result<CompiledImportPlan, String> {
+    let mapped = mapping_indexes_for_columns(columns, mappings)?;
+    let mapped_source_indexes = mapped.iter().map(|(source_index, _)| *source_index).collect::<Vec<_>>();
+    let target_columns = mapped.into_iter().map(|(_, target)| target).collect::<Vec<_>>();
+    let column_types = target_columns
+        .iter()
+        .map(|column| {
+            target_column_types
+                .iter()
+                .find(|(name, _)| name.eq_ignore_ascii_case(column))
+                .map(|(_, data_type)| data_type.clone())
+        })
+        .collect::<Vec<_>>();
+    Ok(CompiledImportPlan { mapped_source_indexes, target_columns, column_types })
+}
+
 pub fn build_import_insert_batch_from_rows(
     rows: &[Vec<serde_json::Value>],
     columns: &[String],
@@ -1502,41 +2894,117 @@ fn build_import_insert_batch_from_rows_with_format(
             rows.len(),
         );
     }
-    let mapped = mapping_indexes_for_columns(columns, mappings)?;
-    let target_columns = mapped.iter().map(|(_, target)| target.clone()).collect::<Vec<_>>();
-    let column_types = target_columns
-        .iter()
-        .map(|column| {
-            target_column_types
-                .iter()
-                .find(|(name, _)| name.eq_ignore_ascii_case(column))
-                .map(|(_, data_type)| data_type.clone())
-        })
-        .collect::<Vec<_>>();
-    let mapped_rows = rows
-        .iter()
+    let plan = compile_import_plan(columns, mappings, target_column_types)?;
+    build_import_insert_batch_with_plan(rows, &plan, table, schema, db_type, date_time_format)
+}
+
+fn build_import_insert_batch_with_plan(
+    rows: &[Vec<serde_json::Value>],
+    plan: &CompiledImportPlan,
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    date_time_format: Option<&str>,
+) -> Result<Option<ImportSqlBatch>, String> {
+    if rows.is_empty() {
+        return Ok(None);
+    }
+    let mapped_rows = map_import_rows_with_plan(rows, plan, db_type, date_time_format);
+    let sql = generate_insert_typed(&plan.target_columns, &plan.column_types, &mapped_rows, table, schema, db_type);
+    Ok((!sql.trim().is_empty()).then_some(ImportSqlBatch { sql, row_count: rows.len() }))
+}
+
+fn build_import_insert_batches_with_plan(
+    rows: &[Vec<serde_json::Value>],
+    plan: &CompiledImportPlan,
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    date_time_format: Option<&str>,
+) -> Vec<ImportSqlBatch> {
+    if rows.is_empty() {
+        return Vec::new();
+    }
+    let mapped_rows = map_import_rows_with_plan(rows, plan, db_type, date_time_format);
+    generate_insert_typed_sql_batches(
+        &plan.target_columns,
+        &plan.column_types,
+        &mapped_rows,
+        table,
+        schema,
+        db_type,
+        rows.len(),
+    )
+    .into_iter()
+    .map(|(sql, row_count)| ImportSqlBatch { sql, row_count })
+    .collect()
+}
+
+fn map_import_rows_with_plan(
+    rows: &[Vec<serde_json::Value>],
+    plan: &CompiledImportPlan,
+    db_type: &DatabaseType,
+    date_time_format: Option<&str>,
+) -> Vec<Vec<serde_json::Value>> {
+    rows.iter()
         .map(|row| {
-            mapped
+            plan.mapped_source_indexes
                 .iter()
                 .enumerate()
-                .map(|(target_index, (source_index, _))| {
+                .map(|(target_index, source_index)| {
                     let value = row.get(*source_index).cloned().unwrap_or(serde_json::Value::Null);
                     normalize_import_value(
                         &value,
-                        column_types.get(target_index).and_then(|data_type| data_type.as_deref()),
+                        plan.column_types.get(target_index).and_then(|data_type| data_type.as_deref()),
                         db_type,
                         date_time_format,
                     )
                 })
                 .collect::<Vec<_>>()
         })
-        .collect::<Vec<_>>();
-    let sql = generate_insert_typed(&target_columns, &column_types, &mapped_rows, table, schema, db_type);
-    Ok((!sql.trim().is_empty()).then_some(ImportSqlBatch { sql, row_count: rows.len() }))
+        .collect::<Vec<_>>()
 }
 
-fn supports_multi_row_insert_values(db_type: &DatabaseType) -> bool {
-    !matches!(db_type, DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Iris)
+#[allow(clippy::too_many_arguments)]
+fn build_import_execution_batches(
+    rows: &[Vec<serde_json::Value>],
+    plan: Option<&CompiledImportPlan>,
+    columns: &[String],
+    mappings: &[TableImportColumnMapping],
+    target_column_types: &[(String, String)],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    date_time_format: Option<&str>,
+) -> Result<Vec<ImportSqlBatch>, String> {
+    if let Some(plan) = plan {
+        return Ok(build_import_insert_batches_with_plan(rows, plan, table, schema, db_type, date_time_format));
+    }
+    if *db_type == DatabaseType::CloudflareD1 {
+        return crate::db::cloudflare_d1::build_import_insert_batches(
+            rows,
+            columns,
+            mappings,
+            target_column_types,
+            table,
+            schema,
+            rows.len().max(1),
+        );
+    }
+    let plan = compile_import_plan(columns, mappings, target_column_types)?;
+    Ok(build_import_insert_batches_with_plan(rows, &plan, table, schema, db_type, date_time_format))
+}
+
+fn effective_import_batch_size(db_type: &DatabaseType, requested: usize) -> usize {
+    // Some backends impose stricter limits than the UI batch setting; clamp here so every
+    // import path, including streaming producers, uses the same safe value.
+    let max_rows = match db_type {
+        DatabaseType::Oracle => MAX_ORACLE_IMPORT_BATCH_ROWS,
+        DatabaseType::OceanbaseOracle | DatabaseType::Iris => 1,
+        DatabaseType::CloudflareD1 => 100,
+        _ => usize::MAX,
+    };
+    requested.max(1).min(max_rows)
 }
 
 fn normalize_import_temporal_value(
@@ -1656,17 +3124,6 @@ fn build_import_insert_batches_with_format(
     batch_size: usize,
     date_time_format: Option<&str>,
 ) -> Result<Vec<ImportSqlBatch>, String> {
-    let mapped = mapping_indexes(data, mappings)?;
-    let columns = mapped.iter().map(|(_, target)| target.clone()).collect::<Vec<_>>();
-    let column_types = columns
-        .iter()
-        .map(|column| {
-            target_column_types
-                .iter()
-                .find(|(name, _)| name.eq_ignore_ascii_case(column))
-                .map(|(_, data_type)| data_type.clone())
-        })
-        .collect::<Vec<_>>();
     if *db_type == DatabaseType::CloudflareD1 {
         return crate::db::cloudflare_d1::build_import_insert_batches(
             &data.rows,
@@ -1675,39 +3132,15 @@ fn build_import_insert_batches_with_format(
             target_column_types,
             table,
             schema,
-            batch_size.clamp(1, 100),
+            effective_import_batch_size(db_type, batch_size),
         );
     }
-    // Drivers without multi-row VALUES support still benefit from the agent
-    // batching the generated single-row statements during execution.
-    let batch_size = if supports_multi_row_insert_values(db_type) { batch_size.max(1) } else { 1 };
+    let plan = compile_import_plan(&data.columns, mappings, target_column_types)?;
+    let batch_size = effective_import_batch_size(db_type, batch_size);
     let mut batches = Vec::new();
-
-    for chunk in data.rows.chunks(batch_size) {
-        let rows = chunk
-            .iter()
-            .map(|row| {
-                mapped
-                    .iter()
-                    .enumerate()
-                    .map(|(target_index, (source_index, _))| {
-                        let value = row.get(*source_index).cloned().unwrap_or(serde_json::Value::Null);
-                        normalize_import_value(
-                            &value,
-                            column_types.get(target_index).and_then(|data_type| data_type.as_deref()),
-                            db_type,
-                            date_time_format,
-                        )
-                    })
-                    .collect::<Vec<_>>()
-            })
-            .collect::<Vec<_>>();
-        let sql = generate_insert_typed(&columns, &column_types, &rows, table, schema, db_type);
-        if !sql.trim().is_empty() {
-            batches.push(ImportSqlBatch { sql, row_count: chunk.len() });
-        }
+    for rows in data.rows.chunks(batch_size) {
+        batches.extend(build_import_insert_batches_with_plan(rows, &plan, table, schema, db_type, date_time_format));
     }
-
     Ok(batches)
 }
 
@@ -2009,24 +3442,398 @@ fn import_error_message(request: &TableImportRequest, rows_imported: usize, erro
     format!("Import into table '{}' failed after {} imported rows: {}", request.table, rows_imported, error.as_ref())
 }
 
+fn import_progress(
+    import_id: &str,
+    status: TableImportStatus,
+    rows_imported: usize,
+    total_rows: usize,
+    started_at: Instant,
+    error: Option<String>,
+) -> TableImportProgress {
+    let phase = match status {
+        TableImportStatus::Running => TableImportPhase::Writing,
+        TableImportStatus::Done | TableImportStatus::Error | TableImportStatus::Cancelled => TableImportPhase::Done,
+    };
+    import_progress_with_details(import_id, status, phase, rows_imported, total_rows, true, 0, 0, started_at, error)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn import_progress_with_details(
+    import_id: &str,
+    status: TableImportStatus,
+    phase: TableImportPhase,
+    rows_imported: usize,
+    total_rows: usize,
+    total_rows_exact: bool,
+    bytes_read: u64,
+    total_bytes: u64,
+    started_at: Instant,
+    error: Option<String>,
+) -> TableImportProgress {
+    TableImportProgress {
+        import_id: import_id.to_string(),
+        status,
+        phase,
+        rows_imported,
+        total_rows,
+        total_rows_exact,
+        bytes_read,
+        total_bytes,
+        elapsed_ms: started_at.elapsed().as_millis(),
+        error,
+    }
+}
+
+fn import_summary(import_id: &str, rows_imported: usize, total_rows: usize, started_at: Instant) -> TableImportSummary {
+    TableImportSummary {
+        import_id: import_id.to_string(),
+        rows_imported,
+        total_rows,
+        elapsed_ms: started_at.elapsed().as_millis(),
+    }
+}
+
+async fn execute_import_statement(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    db_write_ms: &mut u128,
+    statement_count: &mut usize,
+) -> Result<crate::db::QueryResult, String> {
+    let started_at = Instant::now();
+    let result = execute_on_pool(state, pool_key, sql).await;
+    *db_write_ms += started_at.elapsed().as_millis();
+    *statement_count += 1;
+    result
+}
+
+fn postgres_copy_text_value(value: &serde_json::Value) -> Result<String, String> {
+    let raw = match value {
+        serde_json::Value::Null => return Ok("\\N".to_string()),
+        serde_json::Value::Bool(value) => value.to_string(),
+        serde_json::Value::Number(value) => value.to_string(),
+        serde_json::Value::String(value) => value.clone(),
+        serde_json::Value::Array(_) | serde_json::Value::Object(_) => {
+            return Err("PostgreSQL COPY fast path does not support structured values".to_string())
+        }
+    };
+    if raw.contains('\0') {
+        return Err("PostgreSQL COPY text format does not support NUL bytes".to_string());
+    }
+    let mut escaped = String::with_capacity(raw.len());
+    for ch in raw.chars() {
+        match ch {
+            '\\' => escaped.push_str("\\\\"),
+            '\t' => escaped.push_str("\\t"),
+            '\n' => escaped.push_str("\\n"),
+            '\r' => escaped.push_str("\\r"),
+            '\u{0008}' => escaped.push_str("\\b"),
+            '\u{000C}' => escaped.push_str("\\f"),
+            '\u{000B}' => escaped.push_str("\\v"),
+            _ => escaped.push(ch),
+        }
+    }
+    Ok(escaped)
+}
+
+fn postgres_copy_compatible_column_type(data_type: Option<&str>) -> bool {
+    let Some(data_type) = data_type else {
+        return true;
+    };
+    let base = data_type.trim().to_ascii_lowercase();
+    !base.starts_with("bytea") && !base.starts_with("bit") && !base.starts_with("varbit")
+}
+
+fn build_postgres_copy_text_batch(
+    rows: &[Vec<serde_json::Value>],
+    plan: &CompiledImportPlan,
+    table: &str,
+    schema: &str,
+    date_time_format: Option<&str>,
+) -> Result<(String, Vec<u8>), String> {
+    let mapped_rows = map_import_rows_with_plan(rows, plan, &DatabaseType::Postgres, date_time_format);
+    let mut data = String::new();
+    for row in mapped_rows {
+        for (index, value) in row.iter().enumerate() {
+            if index > 0 {
+                data.push('\t');
+            }
+            data.push_str(&postgres_copy_text_value(value)?);
+        }
+        data.push('\n');
+    }
+    let table = qualified_table(table, schema, &DatabaseType::Postgres);
+    let columns = plan
+        .target_columns
+        .iter()
+        .map(|column| quote_identifier(column, &DatabaseType::Postgres))
+        .collect::<Vec<_>>()
+        .join(", ");
+    Ok((format!("COPY {table} ({columns}) FROM STDIN WITH (FORMAT text)"), data.into_bytes()))
+}
+
+async fn execute_postgres_copy_batch(
+    state: &AppState,
+    pool_key: &str,
+    sql: &str,
+    data: &[u8],
+    db_write_ms: &mut u128,
+    statement_count: &mut usize,
+) -> Result<(), String> {
+    let pool = {
+        let connections = state.connections.read().await;
+        match connections.get(pool_key) {
+            Some(PoolKind::Postgres(pool)) => pool.clone(),
+            _ => return Err("PostgreSQL pool not found for COPY import".to_string()),
+        }
+    };
+    let started_at = Instant::now();
+    let result = crate::db::postgres::copy_in(&pool, sql, data).await;
+    *db_write_ms += started_at.elapsed().as_millis();
+    *statement_count += 1;
+    result
+}
+
+fn postgres_copy_eligibility_sql(table: &str, schema: &str) -> String {
+    let table = table.replace('\'', "''");
+    let schema_filter = if schema.trim().is_empty() {
+        "n.nspname = current_schema()".to_string()
+    } else {
+        format!("n.nspname = '{}'", schema.replace('\'', "''"))
+    };
+    format!(
+        "SELECT NOT c.relrowsecurity AND NOT c.relhasrules AS copy_eligible \
+         FROM pg_catalog.pg_class c \
+         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
+         WHERE {schema_filter} AND c.relname = '{table}' AND c.relkind IN ('r', 'p') \
+         LIMIT 1"
+    )
+}
+
+async fn postgres_copy_fast_path_eligible(state: &AppState, pool_key: &str, table: &str, schema: &str) -> bool {
+    let sql = postgres_copy_eligibility_sql(table, schema);
+    match execute_on_pool(state, pool_key, &sql).await {
+        Ok(result) => result.rows.first().and_then(|row| row.first()).is_some_and(|value| match value {
+            serde_json::Value::Bool(value) => *value,
+            serde_json::Value::String(value) => {
+                matches!(value.trim().to_ascii_lowercase().as_str(), "1" | "t" | "true")
+            }
+            serde_json::Value::Number(value) => value.as_u64() == Some(1),
+            _ => false,
+        }),
+        Err(error) => {
+            log::debug!("PostgreSQL COPY eligibility check failed; using INSERT fallback: {error}");
+            false
+        }
+    }
+}
+
+#[derive(Debug)]
+struct ImportRowsBatchError {
+    rows_imported: usize,
+    message: String,
+}
+
+impl ImportRowsBatchError {
+    fn before_write(message: impl Into<String>) -> Self {
+        Self { rows_imported: 0, message: message.into() }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct ImportBatchExecutionPolicy {
+    transactional: bool,
+    include_truncate: bool,
+    allow_postgres_copy: bool,
+}
+
+fn supports_transactional_import_truncate(db_type: &DatabaseType) -> bool {
+    matches!(
+        db_type,
+        DatabaseType::Postgres
+            | DatabaseType::Kingbase
+            | DatabaseType::Sqlite
+            | DatabaseType::CloudflareD1
+            | DatabaseType::SqlServer
+    )
+}
+
+fn supports_import_batch_transactions(db_type: &DatabaseType) -> bool {
+    // These native drivers do not expose a transaction spanning separate requests.
+    // Agent-backed JDBC drivers perform their own supportsTransactions check.
+    !matches!(db_type, DatabaseType::ClickHouse | DatabaseType::Rqlite | DatabaseType::Turso)
+}
+
+fn import_batch_execution_policy(
+    mode: &TableImportMode,
+    pending_truncate: bool,
+    db_type: &DatabaseType,
+) -> ImportBatchExecutionPolicy {
+    let transactional = matches!(mode, TableImportMode::Truncate) && supports_import_batch_transactions(db_type);
+    let include_truncate = transactional && pending_truncate;
+    ImportBatchExecutionPolicy {
+        transactional,
+        include_truncate,
+        allow_postgres_copy: *db_type == DatabaseType::Postgres && !include_truncate,
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn execute_import_transaction(
+    state: &AppState,
+    pool_key: &str,
+    connection_id: &str,
+    database: &str,
+    schema: &str,
+    statements: &[String],
+    db_write_ms: &mut u128,
+    statement_count: &mut usize,
+) -> Result<crate::db::QueryResult, String> {
+    let started_at = Instant::now();
+    let result = crate::query::execute_statements_in_transaction_on_pool(
+        state,
+        pool_key,
+        connection_id,
+        database,
+        statements,
+        (!schema.trim().is_empty()).then_some(schema),
+    )
+    .await;
+    *db_write_ms += started_at.elapsed().as_millis();
+    *statement_count += statements.len();
+    result
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn execute_import_rows_batch(
+    state: &AppState,
+    pool_key: &str,
+    connection_id: &str,
+    database: &str,
+    rows: &[Vec<serde_json::Value>],
+    plan: Option<&CompiledImportPlan>,
+    columns: &[String],
+    mappings: &[TableImportColumnMapping],
+    target_column_types: &[(String, String)],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    mode: &TableImportMode,
+    pending_truncate: bool,
+    allow_postgres_copy: bool,
+    date_time_format: Option<&str>,
+    db_write_ms: &mut u128,
+    statement_count: &mut usize,
+) -> Result<usize, ImportRowsBatchError> {
+    let execution_policy = import_batch_execution_policy(mode, pending_truncate, db_type);
+    // COPY is used only for plain scalar PostgreSQL rows and ordinary tables. Any unsupported
+    // value or table feature falls through to the portable INSERT generator below.
+    if allow_postgres_copy
+        && execution_policy.allow_postgres_copy
+        && *db_type == DatabaseType::Postgres
+        && !rows
+            .iter()
+            .flatten()
+            .any(|value| matches!(value, serde_json::Value::Array(_) | serde_json::Value::Object(_)))
+    {
+        if let Some(plan) = plan {
+            if plan.column_types.iter().all(|data_type| postgres_copy_compatible_column_type(data_type.as_deref())) {
+                let (copy_sql, copy_data) = build_postgres_copy_text_batch(rows, plan, table, schema, date_time_format)
+                    .map_err(ImportRowsBatchError::before_write)?;
+                execute_postgres_copy_batch(state, pool_key, &copy_sql, &copy_data, db_write_ms, statement_count)
+                    .await
+                    .map_err(ImportRowsBatchError::before_write)?;
+                return Ok(rows.len());
+            }
+        }
+    }
+    let batches = build_import_execution_batches(
+        rows,
+        plan,
+        columns,
+        mappings,
+        target_column_types,
+        table,
+        schema,
+        db_type,
+        date_time_format,
+    )
+    .map_err(ImportRowsBatchError::before_write)?;
+    if execution_policy.transactional {
+        let mut statements = Vec::with_capacity(batches.len() + usize::from(execution_policy.include_truncate));
+        if execution_policy.include_truncate {
+            statements.push(truncate_sql(table, schema, db_type));
+        }
+        statements.extend(batches.into_iter().map(|batch| batch.sql));
+        execute_import_transaction(
+            state,
+            pool_key,
+            connection_id,
+            database,
+            schema,
+            &statements,
+            db_write_ms,
+            statement_count,
+        )
+        .await
+        .map_err(ImportRowsBatchError::before_write)?;
+        return Ok(rows.len());
+    }
+    let mut rows_imported = 0usize;
+    for batch in batches {
+        if let Err(error) = execute_import_statement(state, pool_key, &batch.sql, db_write_ms, statement_count).await {
+            return Err(ImportRowsBatchError { rows_imported, message: error });
+        }
+        rows_imported = rows_imported.saturating_add(batch.row_count);
+    }
+    Ok(rows_imported)
+}
+
+fn log_import_metrics(
+    request: &TableImportRequest,
+    source_format: TableImportSourceFormat,
+    rows_imported: usize,
+    started_at: Instant,
+    db_write_ms: u128,
+    statement_count: usize,
+) {
+    let elapsed_ms = started_at.elapsed().as_millis();
+    let non_db_ms = elapsed_ms.saturating_sub(db_write_ms);
+    let rows_per_second =
+        if elapsed_ms == 0 { rows_imported as f64 } else { rows_imported as f64 * 1000.0 / elapsed_ms as f64 };
+    log::info!(
+        "[table-import:done] import_id={} format={} rows={} elapsed_ms={} db_write_ms={} non_db_ms={} statements={} rows_per_second={:.1}",
+        request.import_id,
+        source_format.label(),
+        rows_imported,
+        elapsed_ms,
+        db_write_ms,
+        non_db_ms,
+        statement_count,
+        rows_per_second,
+    );
+}
+
 fn emit_import_error<F>(
     progress_callback: &mut F,
     request: &TableImportRequest,
     rows_imported: usize,
     total_rows: usize,
+    started_at: Instant,
     error: impl AsRef<str>,
 ) -> String
 where
     F: FnMut(TableImportProgress),
 {
     let message = import_error_message(request, rows_imported, error);
-    progress_callback(TableImportProgress {
-        import_id: request.import_id.clone(),
-        status: TableImportStatus::Error,
+    progress_callback(import_progress(
+        &request.import_id,
+        TableImportStatus::Error,
         rows_imported,
         total_rows,
-        error: Some(message.clone()),
-    });
+        started_at,
+        Some(message.clone()),
+    ));
     message
 }
 
@@ -2075,33 +3882,132 @@ fn delimited_columns_and_first_record<R: std::io::Read>(
     Err("Import file has no data rows in the selected row range".to_string())
 }
 
+#[derive(Debug)]
+enum DelimitedStreamMessage {
+    Header(Vec<String>),
+    Rows { rows: Vec<Vec<serde_json::Value>>, bytes_read: u64 },
+    Done,
+}
+
+fn stream_delimited_rows_to_channel(
+    path: &str,
+    source_format: TableImportSourceFormat,
+    options: &TableImportParseOptions,
+    batch_size: usize,
+    sender: tokio::sync::mpsc::Sender<Result<DelimitedStreamMessage, String>>,
+) -> Result<(), String> {
+    // Keep CSV parsing off the async executor while the bounded channel prevents unbounded
+    // accumulation when the database consumer is under load.
+    let (mut reader, config, _) = open_delimited_csv_reader_with_progress(path, source_format, options, |_| {})?;
+    let (columns, first_record) = delimited_columns_and_first_record(&mut reader, config)?;
+    sender
+        .blocking_send(Ok(DelimitedStreamMessage::Header(columns.clone())))
+        .map_err(|_| "Delimited import consumer closed before the stream started".to_string())?;
+
+    let batch_size = batch_size.max(1);
+    let mut pending_rows = Vec::with_capacity(batch_size);
+    let mut next_record = first_record;
+    let mut source_row_number = config.row_range.data_start_row.saturating_sub(1);
+    loop {
+        let record = if let Some(record) = next_record.take() {
+            record
+        } else {
+            let mut record = csv::StringRecord::new();
+            if !reader.read_record(&mut record).map_err(|error| error.to_string())? {
+                break;
+            }
+            record
+        };
+        source_row_number = source_row_number.saturating_add(1);
+        if config.row_range.last_data_row.is_some_and(|last| source_row_number > last) {
+            break;
+        }
+        pending_rows.push(delimited_record_to_row(&record, columns.len(), config));
+        if pending_rows.len() >= batch_size {
+            sender
+                .blocking_send(Ok(DelimitedStreamMessage::Rows {
+                    rows: std::mem::take(&mut pending_rows),
+                    bytes_read: reader.get_ref().source_bytes_read(),
+                }))
+                .map_err(|_| "Delimited import consumer closed before the stream finished".to_string())?;
+            pending_rows = Vec::with_capacity(batch_size);
+        }
+    }
+    if !pending_rows.is_empty() {
+        sender
+            .blocking_send(Ok(DelimitedStreamMessage::Rows {
+                rows: pending_rows,
+                bytes_read: reader.get_ref().source_bytes_read(),
+            }))
+            .map_err(|_| "Delimited import consumer closed before the stream finished".to_string())?;
+    }
+    sender
+        .blocking_send(Ok(DelimitedStreamMessage::Done))
+        .map_err(|_| "Delimited import consumer closed before the stream finished".to_string())?;
+    Ok(())
+}
+
+fn import_source_fingerprint(
+    path: &str,
+    format: TableImportSourceFormat,
+    options: &TableImportParseOptions,
+) -> Result<String, String> {
+    let metadata = std::fs::metadata(path).map_err(|error| error.to_string())?;
+    let modified_nanos = metadata
+        .modified()
+        .ok()
+        .and_then(|modified| modified.duration_since(UNIX_EPOCH).ok())
+        .map(|duration| duration.as_nanos())
+        .unwrap_or_default();
+    let canonical_path = std::fs::canonicalize(path).unwrap_or_else(|_| Path::new(path).to_path_buf());
+    let mut hasher = Sha256::new();
+    hasher.update(canonical_path.to_string_lossy().as_bytes());
+    hasher.update(metadata.len().to_le_bytes());
+    hasher.update(modified_nanos.to_le_bytes());
+    hasher.update(format.label().as_bytes());
+    hasher.update(serde_json::to_vec(options).map_err(|error| error.to_string())?);
+    Ok(format!("{:x}", hasher.finalize()))
+}
+
+fn validated_prepared_import_source(
+    request: &TableImportRequest,
+    format: TableImportSourceFormat,
+) -> Option<ParsedImportFile> {
+    let prepared = request.prepared_source.as_ref()?;
+    if prepared.columns.is_empty() || prepared.total_rows == 0 {
+        return None;
+    }
+    // Preview rows are reusable only while the source metadata and all parse options still match.
+    let fingerprint = import_source_fingerprint(&request.file_path, format, &request.parse_options).ok()?;
+    if fingerprint != prepared.fingerprint {
+        return None;
+    }
+    Some(ParsedImportFile {
+        columns: prepared.columns.clone(),
+        rows: prepared.rows.clone(),
+        total_rows: prepared.total_rows,
+        effective_encoding: prepared.effective_encoding,
+    })
+}
+
 pub async fn preview_table_import_file_with_request(
     request: TableImportPreviewRequest,
 ) -> Result<TableImportPreview, String> {
     let format = effective_source_format(&request.file_path, request.source_format)?;
-    let parsed = parse_import_file_with_options(
+    let (parsed, total_rows_exact, sheets) = parse_import_preview_file_with_options(
         &request.file_path,
-        Some(format),
+        format,
         &request.parse_options,
         request.preview_limit.unwrap_or(DEFAULT_PREVIEW_LIMIT),
     )
     .await?;
     let metadata = tokio::fs::metadata(&request.file_path).await.map_err(|e| e.to_string())?;
+    let source_fingerprint = import_source_fingerprint(&request.file_path, format, &request.parse_options)?;
     let file_name = Path::new(&request.file_path)
         .file_name()
         .and_then(|name| name.to_str())
         .unwrap_or(&request.file_path)
         .to_string();
-    let sheets = if matches!(format, TableImportSourceFormat::Excel) {
-        let file_path = request.file_path.clone();
-        tokio::task::spawn_blocking(move || xlsx_sheet_names(&file_path))
-            .await
-            .map_err(|e| e.to_string())?
-            .unwrap_or_default()
-    } else {
-        Vec::new()
-    };
-
     Ok(TableImportPreview {
         file_name,
         file_path: request.file_path,
@@ -2111,6 +4017,8 @@ pub async fn preview_table_import_file_with_request(
         columns: parsed.columns,
         rows: parsed.rows,
         total_rows: parsed.total_rows,
+        total_rows_exact,
+        source_fingerprint,
         effective_encoding: parsed.effective_encoding,
         sheets,
     })
@@ -2140,11 +4048,14 @@ pub async fn import_table_file_core<F>(
 where
     F: FnMut(TableImportProgress),
 {
+    let started_at = Instant::now();
+    let mut db_write_ms = 0u128;
+    let mut statement_count = 0usize;
     let batch_size = if request.batch_size == 0 { DEFAULT_BATCH_SIZE } else { request.batch_size };
     let source_format = match effective_source_format(&request.file_path, request.source_format) {
         Ok(format) => format,
         Err(error) => {
-            return Err(emit_import_error(&mut progress_callback, request, 0, 0, error));
+            return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
         }
     };
 
@@ -2154,9 +4065,82 @@ where
             request,
             0,
             0,
+            started_at,
             format!("Import source is no longer available: {error}"),
         ));
     }
+    let prepared_source = validated_prepared_import_source(request, source_format);
+    let prepared_source_total_exact =
+        prepared_source.is_some() && request.prepared_source.as_ref().is_some_and(|prepared| prepared.total_rows_exact);
+
+    // Validate the entire text source before writing so a malformed tail cannot leave partial batches behind.
+    let validated_text_encoding = if source_format.is_delimited() {
+        let total_bytes = tokio::fs::metadata(&request.file_path).await.map(|metadata| metadata.len()).unwrap_or(0);
+        progress_callback(import_progress_with_details(
+            &request.import_id,
+            TableImportStatus::Running,
+            TableImportPhase::DetectingEncoding,
+            0,
+            0,
+            false,
+            0,
+            total_bytes,
+            started_at,
+            None,
+        ));
+        let mut last_encoding_progress_emit = Instant::now() - IMPORT_PROGRESS_INTERVAL;
+        let path = request.file_path.clone();
+        let requested_encoding = request.parse_options.encoding;
+        let (encoding_progress_sender, mut encoding_progress_receiver) = tokio::sync::mpsc::channel(16);
+        let validation = tokio::task::spawn_blocking(move || {
+            let mut last_progress_send = Instant::now() - IMPORT_PROGRESS_INTERVAL;
+            resolve_and_validate_text_encoding_from_file(&path, requested_encoding, |bytes_read| {
+                if last_progress_send.elapsed() >= IMPORT_PROGRESS_INTERVAL
+                    || (total_bytes > 0 && bytes_read >= total_bytes)
+                {
+                    let _ = encoding_progress_sender.blocking_send(bytes_read);
+                    last_progress_send = Instant::now();
+                }
+            })
+        });
+        while let Some(bytes_read) = encoding_progress_receiver.recv().await {
+            if last_encoding_progress_emit.elapsed() >= IMPORT_PROGRESS_INTERVAL
+                || (total_bytes > 0 && bytes_read >= total_bytes)
+            {
+                progress_callback(import_progress_with_details(
+                    &request.import_id,
+                    TableImportStatus::Running,
+                    TableImportPhase::DetectingEncoding,
+                    0,
+                    0,
+                    false,
+                    bytes_read.min(total_bytes),
+                    total_bytes,
+                    started_at,
+                    None,
+                ));
+                last_encoding_progress_emit = Instant::now();
+            }
+        }
+        let validation = match validation.await {
+            Ok(validation) => validation,
+            Err(error) => {
+                return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error.to_string()));
+            }
+        };
+        match validation {
+            Ok(resolved) => Some(resolved),
+            Err(error) => {
+                return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+            }
+        }
+    } else {
+        None
+    };
+    let mut import_parse_options = request.parse_options.clone();
+    if let Some((encoding, _)) = validated_text_encoding {
+        import_parse_options.encoding = Some(encoding);
+    }
 
     let mut create_table_sample: Option<ParsedImportFile> = None;
     let mut created_column_types: Option<Vec<(String, String)>> = None;
@@ -2167,20 +4151,35 @@ where
                 request,
                 0,
                 0,
+                started_at,
                 "Cannot truncate a table that is being created by the import",
             ));
         }
-        let parsed = match parse_import_file_with_options(
-            &request.file_path,
-            Some(source_format),
-            &request.parse_options,
-            CREATE_TABLE_INFERENCE_ROWS,
-        )
-        .await
+        let required_sample_rows = if prepared_source_total_exact {
+            prepared_source
+                .as_ref()
+                .map(|prepared| prepared.total_rows.min(CREATE_TABLE_INFERENCE_ROWS))
+                .unwrap_or(CREATE_TABLE_INFERENCE_ROWS)
+        } else {
+            CREATE_TABLE_INFERENCE_ROWS
+        };
+        let parsed = if let Some(prepared) =
+            prepared_source.as_ref().filter(|prepared| prepared.rows.len() >= required_sample_rows).cloned()
         {
-            Ok(parsed) => parsed,
-            Err(error) => {
-                return Err(emit_import_error(&mut progress_callback, request, 0, 0, error));
+            prepared
+        } else {
+            match parse_import_preview_file_with_options(
+                &request.file_path,
+                source_format,
+                &import_parse_options,
+                CREATE_TABLE_INFERENCE_ROWS,
+            )
+            .await
+            {
+                Ok((parsed, _, _)) => parsed,
+                Err(error) => {
+                    return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+                }
             }
         };
         let total_rows = parsed.total_rows;
@@ -2193,13 +4192,15 @@ where
         ) {
             Ok(plan) => plan,
             Err(error) => {
-                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
             }
         };
         // The table must be created before streaming rows so existing import batching
         // can reuse the same INSERT path and database-specific value escaping.
-        if let Err(error) = execute_on_pool(state, pool_key, &plan.sql).await {
-            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+        if let Err(error) =
+            execute_import_statement(state, pool_key, &plan.sql, &mut db_write_ms, &mut statement_count).await
+        {
+            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
         }
         created_column_types =
             Some(plan.columns.iter().map(|column| (column.name.clone(), column.data_type.clone())).collect());
@@ -2207,30 +4208,27 @@ where
     }
 
     if source_format.is_delimited() {
-        let parsed = if let Some(parsed) = create_table_sample.clone() {
+        let parsed = if let Some(parsed) = create_table_sample.clone().or_else(|| prepared_source.clone()) {
             parsed
         } else {
-            match parse_import_file_with_options(&request.file_path, Some(source_format), &request.parse_options, 0)
+            match parse_import_preview_file_with_options(&request.file_path, source_format, &import_parse_options, 1)
                 .await
             {
-                Ok(parsed) => parsed,
+                Ok((parsed, _, _)) => parsed,
                 Err(error) => {
-                    return Err(emit_import_error(&mut progress_callback, request, 0, 0, error));
+                    return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
                 }
             }
         };
-        let total_rows = parsed.total_rows;
+        let known_total_rows = prepared_source_total_exact.then_some(parsed.total_rows);
+        let progress_total_rows = known_total_rows.unwrap_or_default();
+        let total_rows = progress_total_rows;
+        let total_rows_exact = known_total_rows.is_some();
         if let Err(error) = mapping_indexes_for_columns(&parsed.columns, &request.mappings) {
-            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+            return Err(emit_import_error(&mut progress_callback, request, 0, progress_total_rows, started_at, error));
         }
 
-        progress_callback(TableImportProgress {
-            import_id: request.import_id.clone(),
-            status: TableImportStatus::Running,
-            rows_imported: 0,
-            total_rows,
-            error: None,
-        });
+        let total_bytes = tokio::fs::metadata(&request.file_path).await.map(|metadata| metadata.len()).unwrap_or(0);
 
         let mut target_column_types = get_columns_for_transfer(
             state,
@@ -2248,157 +4246,554 @@ where
         if target_column_types.is_empty() {
             target_column_types = created_column_types.clone().unwrap_or_default();
         }
-
-        if matches!(request.mode, TableImportMode::Truncate) {
-            let sql = truncate_sql(&request.table, &request.schema, db_type);
-            if let Err(error) = execute_on_pool(state, pool_key, &sql).await {
-                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
-            }
-        }
-
-        let mut streaming_options = request.parse_options.clone();
-        if streaming_options.encoding.unwrap_or(TableImportTextEncoding::Auto) == TableImportTextEncoding::Auto {
-            streaming_options.encoding = parsed.effective_encoding;
-        }
-        let (mut reader, config, _) =
-            match open_delimited_csv_reader(&request.file_path, source_format, &streaming_options) {
-                Ok(result) => result,
-                Err(error) => {
-                    return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
-                }
-            };
-        let (columns, first_record) = match delimited_columns_and_first_record(&mut reader, config) {
-            Ok(result) => result,
-            Err(error) => return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error)),
-        };
-        let effective_batch_size = match db_type {
-            DatabaseType::Oracle | DatabaseType::OceanbaseOracle => 1,
-            DatabaseType::CloudflareD1 => batch_size.clamp(1, 100),
-            _ => batch_size.max(1),
-        };
-        let mut rows_imported = 0;
-        let mut pending_rows: Vec<Vec<serde_json::Value>> = Vec::with_capacity(effective_batch_size);
-
-        if let Some(record) = first_record {
-            pending_rows.push(delimited_record_to_row(&record, columns.len(), config));
-        }
-
-        for (source_row_number, record) in (config.row_range.data_start_row.saturating_add(1)..).zip(reader.records()) {
-            if config.row_range.last_data_row.is_some_and(|last| source_row_number > last) {
-                break;
-            }
-            if is_cancelled(&request.import_id).await {
-                progress_callback(TableImportProgress {
-                    import_id: request.import_id.clone(),
-                    status: TableImportStatus::Cancelled,
-                    rows_imported,
+        let (resolved_encoding, _) =
+            validated_text_encoding.ok_or_else(|| "Delimited import encoding was not validated".to_string())?;
+        let mut streaming_options = import_parse_options.clone();
+        streaming_options.encoding = Some(resolved_encoding);
+        progress_callback(import_progress_with_details(
+            &request.import_id,
+            TableImportStatus::Running,
+            TableImportPhase::Reading,
+            0,
+            progress_total_rows,
+            known_total_rows.is_some(),
+            0,
+            total_bytes,
+            started_at,
+            None,
+        ));
+        let effective_batch_size = effective_import_batch_size(db_type, batch_size);
+        let (sender, mut receiver) = tokio::sync::mpsc::channel::<Result<DelimitedStreamMessage, String>>(2);
+        let path = request.file_path.clone();
+        let producer_options = streaming_options.clone();
+        let producer = tokio::task::spawn_blocking(move || {
+            stream_delimited_rows_to_channel(&path, source_format, &producer_options, effective_batch_size, sender)
+        });
+        let columns = match receiver.recv().await {
+            Some(Ok(DelimitedStreamMessage::Header(columns))) => columns,
+            Some(Ok(_)) => {
+                drop(receiver);
+                let _ = producer.await;
+                return Err(emit_import_error(
+                    &mut progress_callback,
+                    request,
+                    0,
                     total_rows,
-                    error: None,
-                });
-                return Err("Import cancelled".to_string());
+                    started_at,
+                    "Delimited stream did not provide a header before data rows",
+                ));
             }
-
-            let record = match record {
-                Ok(record) => record,
+            Some(Err(error)) => {
+                let _ = producer.await;
+                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
+            }
+            None => {
+                let error = producer
+                    .await
+                    .map_err(|error| error.to_string())?
+                    .err()
+                    .unwrap_or_else(|| "Delimited stream ended before providing a header".to_string());
+                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
+            }
+        };
+        if columns.is_empty() {
+            drop(receiver);
+            let _ = producer.await;
+            return Err(emit_import_error(
+                &mut progress_callback,
+                request,
+                0,
+                total_rows,
+                started_at,
+                "Import file has no columns in the selected row range",
+            ));
+        }
+        if let Err(error) = mapping_indexes_for_columns(&columns, &request.mappings) {
+            drop(receiver);
+            let _ = producer.await;
+            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
+        }
+        let compiled_plan = if *db_type == DatabaseType::CloudflareD1 {
+            None
+        } else {
+            match compile_import_plan(&columns, &request.mappings, &target_column_types) {
+                Ok(plan) => Some(plan),
                 Err(error) => {
+                    drop(receiver);
+                    let _ = producer.await;
+                    return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
+                }
+            }
+        };
+        let allow_postgres_copy = *db_type == DatabaseType::Postgres
+            && postgres_copy_fast_path_eligible(state, pool_key, &request.table, &request.schema).await;
+        let mut pending_truncate =
+            matches!(request.mode, TableImportMode::Truncate) && supports_transactional_import_truncate(db_type);
+        if matches!(request.mode, TableImportMode::Truncate) && !pending_truncate {
+            let sql = truncate_sql(&request.table, &request.schema, db_type);
+            if let Err(error) =
+                execute_import_statement(state, pool_key, &sql, &mut db_write_ms, &mut statement_count).await
+            {
+                drop(receiver);
+                let _ = producer.await;
+                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
+            }
+        }
+        let mut rows_imported = 0usize;
+        let mut last_bytes_read = 0u64;
+        let mut last_progress_emit = Instant::now();
+        loop {
+            let message = match receiver.recv().await {
+                Some(message) => message,
+                None => break,
+            };
+            match message {
+                Ok(DelimitedStreamMessage::Header(_)) => {}
+                Ok(DelimitedStreamMessage::Rows { rows, bytes_read }) => {
+                    last_bytes_read = last_bytes_read.max(bytes_read);
+                    if is_cancelled(&request.import_id).await {
+                        drop(receiver);
+                        let _ = producer.await;
+                        progress_callback(import_progress_with_details(
+                            &request.import_id,
+                            TableImportStatus::Cancelled,
+                            TableImportPhase::Done,
+                            rows_imported,
+                            total_rows,
+                            total_rows_exact,
+                            last_bytes_read.min(total_bytes),
+                            total_bytes,
+                            started_at,
+                            None,
+                        ));
+                        return Err("Import cancelled".to_string());
+                    }
+                    let row_count = match execute_import_rows_batch(
+                        state,
+                        pool_key,
+                        &request.connection_id,
+                        &request.database,
+                        &rows,
+                        compiled_plan.as_ref(),
+                        &columns,
+                        &request.mappings,
+                        &target_column_types,
+                        &request.table,
+                        &request.schema,
+                        db_type,
+                        &request.mode,
+                        pending_truncate,
+                        allow_postgres_copy,
+                        request.date_time_format.as_deref(),
+                        &mut db_write_ms,
+                        &mut statement_count,
+                    )
+                    .await
+                    {
+                        Ok(row_count) => row_count,
+                        Err(error) => {
+                            drop(receiver);
+                            let _ = producer.await;
+                            rows_imported = rows_imported.saturating_add(error.rows_imported);
+                            return Err(emit_import_error(
+                                &mut progress_callback,
+                                request,
+                                rows_imported,
+                                total_rows,
+                                started_at,
+                                error.message,
+                            ));
+                        }
+                    };
+                    rows_imported = rows_imported.saturating_add(row_count);
+                    pending_truncate = false;
+                    if let Some(known_total_rows) = known_total_rows {
+                        rows_imported = rows_imported.min(known_total_rows);
+                    }
+                    if last_progress_emit.elapsed() >= IMPORT_PROGRESS_INTERVAL {
+                        progress_callback(import_progress_with_details(
+                            &request.import_id,
+                            TableImportStatus::Running,
+                            TableImportPhase::Writing,
+                            rows_imported,
+                            total_rows,
+                            total_rows_exact,
+                            last_bytes_read.min(total_bytes),
+                            total_bytes,
+                            started_at,
+                            None,
+                        ));
+                        last_progress_emit = Instant::now();
+                    }
+                }
+                Ok(DelimitedStreamMessage::Done) => break,
+                Err(error) => {
+                    drop(receiver);
+                    let _ = producer.await;
                     return Err(emit_import_error(
                         &mut progress_callback,
                         request,
                         rows_imported,
                         total_rows,
-                        error.to_string(),
-                    ))
+                        started_at,
+                        error,
+                    ));
                 }
-            };
-            pending_rows.push(delimited_record_to_row(&record, columns.len(), config));
-
-            if pending_rows.len() >= effective_batch_size {
-                let batch = match build_import_insert_batch_from_rows_with_format(
-                    &pending_rows,
-                    &columns,
-                    &request.mappings,
-                    &target_column_types,
-                    &request.table,
-                    &request.schema,
-                    db_type,
-                    request.date_time_format.as_deref(),
-                ) {
-                    Ok(Some(batch)) => batch,
-                    Ok(None) => {
-                        pending_rows.clear();
-                        continue;
-                    }
-                    Err(error) => {
-                        return Err(emit_import_error(
-                            &mut progress_callback,
-                            request,
-                            rows_imported,
-                            total_rows,
-                            error,
-                        ))
-                    }
-                };
-                if let Err(error) = execute_on_pool(state, pool_key, &batch.sql).await {
-                    return Err(emit_import_error(&mut progress_callback, request, rows_imported, total_rows, error));
-                }
-                rows_imported = (rows_imported + batch.row_count).min(total_rows);
-                pending_rows.clear();
-                progress_callback(TableImportProgress {
-                    import_id: request.import_id.clone(),
-                    status: TableImportStatus::Running,
+            }
+        }
+        match producer.await {
+            Ok(Ok(())) => {}
+            Ok(Err(error)) => {
+                return Err(emit_import_error(
+                    &mut progress_callback,
+                    request,
                     rows_imported,
                     total_rows,
-                    error: None,
-                });
+                    started_at,
+                    error,
+                ));
+            }
+            Err(error) => {
+                return Err(emit_import_error(
+                    &mut progress_callback,
+                    request,
+                    rows_imported,
+                    total_rows,
+                    started_at,
+                    error.to_string(),
+                ));
             }
         }
 
-        if !pending_rows.is_empty() {
-            if is_cancelled(&request.import_id).await {
-                progress_callback(TableImportProgress {
-                    import_id: request.import_id.clone(),
-                    status: TableImportStatus::Cancelled,
-                    rows_imported,
-                    total_rows,
-                    error: None,
-                });
-                return Err("Import cancelled".to_string());
-            }
-            let batch = match build_import_insert_batch_from_rows_with_format(
-                &pending_rows,
-                &columns,
-                &request.mappings,
-                &target_column_types,
-                &request.table,
-                &request.schema,
-                db_type,
-                request.date_time_format.as_deref(),
-            ) {
-                Ok(Some(batch)) => batch,
-                Ok(None) => ImportSqlBatch { sql: String::new(), row_count: 0 },
-                Err(error) => {
-                    return Err(emit_import_error(&mut progress_callback, request, rows_imported, total_rows, error))
-                }
-            };
-            if !batch.sql.is_empty() {
-                if let Err(error) = execute_on_pool(state, pool_key, &batch.sql).await {
-                    return Err(emit_import_error(&mut progress_callback, request, rows_imported, total_rows, error));
-                }
-                rows_imported = (rows_imported + batch.row_count).min(total_rows);
-            }
-        }
-
-        progress_callback(TableImportProgress {
-            import_id: request.import_id.clone(),
-            status: TableImportStatus::Done,
+        progress_callback(import_progress_with_details(
+            &request.import_id,
+            TableImportStatus::Done,
+            TableImportPhase::Done,
             rows_imported,
-            total_rows,
-            error: None,
-        });
+            rows_imported,
+            true,
+            total_bytes,
+            total_bytes,
+            started_at,
+            None,
+        ));
+        log_import_metrics(request, source_format, rows_imported, started_at, db_write_ms, statement_count);
 
-        return Ok(TableImportSummary { import_id: request.import_id.clone(), rows_imported, total_rows });
+        return Ok(import_summary(&request.import_id, rows_imported, rows_imported, started_at));
     }
 
+    let extension =
+        Path::new(&request.file_path).extension().and_then(|extension| extension.to_str()).unwrap_or_default();
+    if source_format == TableImportSourceFormat::Excel
+        && (extension.eq_ignore_ascii_case("xlsx") || extension.eq_ignore_ascii_case("xlsm"))
+    {
+        let total_bytes = tokio::fs::metadata(&request.file_path).await.map(|metadata| metadata.len()).unwrap_or(0);
+        progress_callback(import_progress_with_details(
+            &request.import_id,
+            TableImportStatus::Running,
+            TableImportPhase::Reading,
+            0,
+            0,
+            false,
+            0,
+            total_bytes,
+            started_at,
+            None,
+        ));
+        let effective_batch_size = effective_import_batch_size(db_type, batch_size);
+        let expected_columns = if let Some(source) = create_table_sample.as_ref().or(prepared_source.as_ref()) {
+            Some(source.columns.clone())
+        } else {
+            match parse_import_preview_file_with_options(&request.file_path, source_format, &import_parse_options, 1)
+                .await
+            {
+                Ok((parsed, _, _)) => Some(parsed.columns),
+                Err(error) => {
+                    return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+                }
+            }
+        };
+        let mut target_column_types = get_columns_for_transfer(
+            state,
+            pool_key,
+            &request.connection_id,
+            &request.database,
+            &request.schema,
+            &request.table,
+        )
+        .await
+        .unwrap_or_default()
+        .into_iter()
+        .map(|column| (column.name, column.data_type))
+        .collect::<Vec<_>>();
+        if target_column_types.is_empty() {
+            target_column_types = created_column_types.clone().unwrap_or_default();
+        }
+        let text_source_columns = textual_source_columns_for_import(&request.mappings, &target_column_types);
+        // No truncate, INSERT, or COPY may run until the selected worksheet parses to EOF.
+        if let Err(error) = validate_xlsx_worksheet_for_import(
+            request.file_path.clone(),
+            request.parse_options.clone(),
+            expected_columns.clone(),
+            text_source_columns.clone(),
+        )
+        .await
+        {
+            return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+        }
+        // Full-sheet validation can take long enough for the user to cancel. Recheck before
+        // starting the producer or executing a non-transactional truncate.
+        if is_cancelled(&request.import_id).await {
+            progress_callback(import_progress_with_details(
+                &request.import_id,
+                TableImportStatus::Cancelled,
+                TableImportPhase::Done,
+                0,
+                0,
+                false,
+                total_bytes,
+                total_bytes,
+                started_at,
+                None,
+            ));
+            return Err("Import cancelled".to_string());
+        }
+        let (sender, mut receiver) = tokio::sync::mpsc::channel::<Result<XlsxStreamMessage, String>>(2);
+        let path = request.file_path.clone();
+        let options = request.parse_options.clone();
+        let producer = tokio::task::spawn_blocking(move || {
+            stream_xlsx_rows_to_channel(
+                &path,
+                &options,
+                effective_batch_size,
+                expected_columns,
+                text_source_columns,
+                false,
+                sender,
+            )
+        });
+        let columns = match receiver.recv().await {
+            Some(Ok(XlsxStreamMessage::Header(columns))) => columns,
+            Some(Ok(_)) => {
+                drop(receiver);
+                let _ = producer.await;
+                return Err(emit_import_error(
+                    &mut progress_callback,
+                    request,
+                    0,
+                    0,
+                    started_at,
+                    "Excel stream did not provide a header before data rows",
+                ));
+            }
+            Some(Err(error)) => {
+                let _ = producer.await;
+                return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+            }
+            None => {
+                let error = producer
+                    .await
+                    .map_err(|error| error.to_string())?
+                    .err()
+                    .unwrap_or_else(|| "Excel stream ended before providing a header".to_string());
+                return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+            }
+        };
+        if columns.is_empty() {
+            drop(receiver);
+            let _ = producer.await;
+            return Err(emit_import_error(
+                &mut progress_callback,
+                request,
+                0,
+                0,
+                started_at,
+                "Import file has no columns in the selected row range",
+            ));
+        }
+        if let Err(error) = mapping_indexes_for_columns(&columns, &request.mappings) {
+            drop(receiver);
+            let _ = producer.await;
+            return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+        }
+        let compiled_plan = if *db_type == DatabaseType::CloudflareD1 {
+            None
+        } else {
+            match compile_import_plan(&columns, &request.mappings, &target_column_types) {
+                Ok(plan) => Some(plan),
+                Err(error) => {
+                    drop(receiver);
+                    let _ = producer.await;
+                    return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+                }
+            }
+        };
+        let allow_postgres_copy = *db_type == DatabaseType::Postgres
+            && postgres_copy_fast_path_eligible(state, pool_key, &request.table, &request.schema).await;
+        let mut pending_truncate =
+            matches!(request.mode, TableImportMode::Truncate) && supports_transactional_import_truncate(db_type);
+        if matches!(request.mode, TableImportMode::Truncate) && !pending_truncate {
+            let sql = truncate_sql(&request.table, &request.schema, db_type);
+            if let Err(error) =
+                execute_import_statement(state, pool_key, &sql, &mut db_write_ms, &mut statement_count).await
+            {
+                drop(receiver);
+                let _ = producer.await;
+                return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
+            }
+        }
+        let mut rows_imported = 0usize;
+        loop {
+            let message = match receiver.recv().await {
+                Some(message) => message,
+                None => break,
+            };
+            match message {
+                Ok(XlsxStreamMessage::Header(_)) => {}
+                Ok(XlsxStreamMessage::Rows(rows)) => {
+                    if is_cancelled(&request.import_id).await {
+                        drop(receiver);
+                        let _ = producer.await;
+                        progress_callback(import_progress_with_details(
+                            &request.import_id,
+                            TableImportStatus::Cancelled,
+                            TableImportPhase::Done,
+                            rows_imported,
+                            0,
+                            false,
+                            0,
+                            total_bytes,
+                            started_at,
+                            None,
+                        ));
+                        return Err("Import cancelled".to_string());
+                    }
+                    let row_count = match execute_import_rows_batch(
+                        state,
+                        pool_key,
+                        &request.connection_id,
+                        &request.database,
+                        &rows,
+                        compiled_plan.as_ref(),
+                        &columns,
+                        &request.mappings,
+                        &target_column_types,
+                        &request.table,
+                        &request.schema,
+                        db_type,
+                        &request.mode,
+                        pending_truncate,
+                        allow_postgres_copy,
+                        request.date_time_format.as_deref(),
+                        &mut db_write_ms,
+                        &mut statement_count,
+                    )
+                    .await
+                    {
+                        Ok(row_count) => row_count,
+                        Err(error) => {
+                            drop(receiver);
+                            let _ = producer.await;
+                            rows_imported = rows_imported.saturating_add(error.rows_imported);
+                            return Err(emit_import_error(
+                                &mut progress_callback,
+                                request,
+                                rows_imported,
+                                0,
+                                started_at,
+                                error.message,
+                            ));
+                        }
+                    };
+                    rows_imported = rows_imported.saturating_add(row_count);
+                    pending_truncate = false;
+                    progress_callback(import_progress_with_details(
+                        &request.import_id,
+                        TableImportStatus::Running,
+                        TableImportPhase::Writing,
+                        rows_imported,
+                        0,
+                        false,
+                        0,
+                        total_bytes,
+                        started_at,
+                        None,
+                    ));
+                }
+                Ok(XlsxStreamMessage::Progress(bytes_read)) => {
+                    progress_callback(import_progress_with_details(
+                        &request.import_id,
+                        TableImportStatus::Running,
+                        TableImportPhase::Writing,
+                        rows_imported,
+                        0,
+                        false,
+                        bytes_read.min(total_bytes),
+                        total_bytes,
+                        started_at,
+                        None,
+                    ));
+                }
+                Ok(XlsxStreamMessage::Done) => break,
+                Err(error) => {
+                    drop(receiver);
+                    let _ = producer.await;
+                    return Err(emit_import_error(
+                        &mut progress_callback,
+                        request,
+                        rows_imported,
+                        0,
+                        started_at,
+                        error,
+                    ));
+                }
+            }
+        }
+        match producer.await {
+            Ok(Ok(())) => {}
+            Ok(Err(error)) => {
+                return Err(emit_import_error(&mut progress_callback, request, rows_imported, 0, started_at, error));
+            }
+            Err(error) => {
+                return Err(emit_import_error(
+                    &mut progress_callback,
+                    request,
+                    rows_imported,
+                    0,
+                    started_at,
+                    error.to_string(),
+                ));
+            }
+        }
+        progress_callback(import_progress_with_details(
+            &request.import_id,
+            TableImportStatus::Done,
+            TableImportPhase::Done,
+            rows_imported,
+            rows_imported,
+            true,
+            total_bytes,
+            total_bytes,
+            started_at,
+            None,
+        ));
+        log_import_metrics(request, source_format, rows_imported, started_at, db_write_ms, statement_count);
+        return Ok(import_summary(&request.import_id, rows_imported, rows_imported, started_at));
+    }
+
+    let total_bytes = tokio::fs::metadata(&request.file_path).await.map(|metadata| metadata.len()).unwrap_or(0);
+    progress_callback(import_progress_with_details(
+        &request.import_id,
+        TableImportStatus::Running,
+        TableImportPhase::Reading,
+        0,
+        0,
+        false,
+        0,
+        total_bytes,
+        started_at,
+        None,
+    ));
     let mut target_column_types = get_columns_for_transfer(
         state,
         pool_key,
@@ -2416,11 +4811,10 @@ where
         target_column_types = created_column_types.clone().unwrap_or_default();
     }
     let text_source_columns = textual_source_columns_for_import(&request.mappings, &target_column_types);
-
     let parsed = match parse_import_file_with_options_and_text_columns(
         &request.file_path,
         Some(source_format),
-        &request.parse_options,
+        &import_parse_options,
         usize::MAX,
         text_source_columns,
     )
@@ -2428,89 +4822,244 @@ where
     {
         Ok(parsed) => parsed,
         Err(error) => {
-            return Err(emit_import_error(&mut progress_callback, request, 0, 0, error));
+            return Err(emit_import_error(&mut progress_callback, request, 0, 0, started_at, error));
         }
     };
 
     let total_rows = parsed.total_rows;
     if let Err(error) = mapping_indexes(&parsed, &request.mappings) {
-        return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+        return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
     }
-    progress_callback(TableImportProgress {
-        import_id: request.import_id.clone(),
-        status: TableImportStatus::Running,
-        rows_imported: 0,
+    progress_callback(import_progress_with_details(
+        &request.import_id,
+        TableImportStatus::Running,
+        TableImportPhase::Writing,
+        0,
         total_rows,
-        error: None,
-    });
+        true,
+        total_bytes,
+        total_bytes,
+        started_at,
+        None,
+    ));
+    let mut last_progress_emit = Instant::now();
 
-    let batches = match build_import_insert_batches_with_format(
-        &parsed,
-        &request.mappings,
-        &target_column_types,
-        &request.table,
-        &request.schema,
-        db_type,
-        batch_size,
-        request.date_time_format.as_deref(),
-    ) {
-        Ok(batches) => batches,
-        Err(error) => {
-            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+    let effective_batch_size = effective_import_batch_size(db_type, batch_size);
+    let compiled_plan = if *db_type == DatabaseType::CloudflareD1 {
+        None
+    } else {
+        match compile_import_plan(&parsed.columns, &request.mappings, &target_column_types) {
+            Ok(plan) => Some(plan),
+            Err(error) => {
+                return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
+            }
         }
     };
+    let allow_postgres_copy = *db_type == DatabaseType::Postgres
+        && postgres_copy_fast_path_eligible(state, pool_key, &request.table, &request.schema).await;
 
-    if matches!(request.mode, TableImportMode::Truncate) {
+    let mut pending_truncate =
+        matches!(request.mode, TableImportMode::Truncate) && supports_transactional_import_truncate(db_type);
+    if matches!(request.mode, TableImportMode::Truncate) && !pending_truncate {
         let sql = truncate_sql(&request.table, &request.schema, db_type);
-        if let Err(error) = execute_on_pool(state, pool_key, &sql).await {
-            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, error));
+        if let Err(error) =
+            execute_import_statement(state, pool_key, &sql, &mut db_write_ms, &mut statement_count).await
+        {
+            return Err(emit_import_error(&mut progress_callback, request, 0, total_rows, started_at, error));
         }
     }
 
     let mut rows_imported = 0;
-    for batch in batches {
+    for rows in parsed.rows.chunks(effective_batch_size) {
         if is_cancelled(&request.import_id).await {
-            progress_callback(TableImportProgress {
-                import_id: request.import_id.clone(),
-                status: TableImportStatus::Cancelled,
+            progress_callback(import_progress(
+                &request.import_id,
+                TableImportStatus::Cancelled,
                 rows_imported,
                 total_rows,
-                error: None,
-            });
+                started_at,
+                None,
+            ));
             return Err("Import cancelled".to_string());
         }
 
-        if let Err(error) = execute_on_pool(state, pool_key, &batch.sql).await {
-            return Err(emit_import_error(&mut progress_callback, request, rows_imported, total_rows, error));
+        let row_count = match execute_import_rows_batch(
+            state,
+            pool_key,
+            &request.connection_id,
+            &request.database,
+            rows,
+            compiled_plan.as_ref(),
+            &parsed.columns,
+            &request.mappings,
+            &target_column_types,
+            &request.table,
+            &request.schema,
+            db_type,
+            &request.mode,
+            pending_truncate,
+            allow_postgres_copy,
+            request.date_time_format.as_deref(),
+            &mut db_write_ms,
+            &mut statement_count,
+        )
+        .await
+        {
+            Ok(row_count) => row_count,
+            Err(error) => {
+                rows_imported = (rows_imported + error.rows_imported).min(total_rows);
+                return Err(emit_import_error(
+                    &mut progress_callback,
+                    request,
+                    rows_imported,
+                    total_rows,
+                    started_at,
+                    error.message,
+                ));
+            }
+        };
+        rows_imported = (rows_imported + row_count).min(total_rows);
+        pending_truncate = false;
+        if last_progress_emit.elapsed() >= IMPORT_PROGRESS_INTERVAL {
+            progress_callback(import_progress(
+                &request.import_id,
+                TableImportStatus::Running,
+                rows_imported,
+                total_rows,
+                started_at,
+                None,
+            ));
+            last_progress_emit = Instant::now();
         }
-        rows_imported = (rows_imported + batch.row_count).min(total_rows);
-        progress_callback(TableImportProgress {
-            import_id: request.import_id.clone(),
-            status: TableImportStatus::Running,
-            rows_imported,
-            total_rows,
-            error: None,
-        });
     }
 
-    progress_callback(TableImportProgress {
-        import_id: request.import_id.clone(),
-        status: TableImportStatus::Done,
+    progress_callback(import_progress(
+        &request.import_id,
+        TableImportStatus::Done,
         rows_imported,
         total_rows,
-        error: None,
-    });
+        started_at,
+        None,
+    ));
+    log_import_metrics(request, source_format, rows_imported, started_at, db_write_ms, statement_count);
 
-    Ok(TableImportSummary { import_id: request.import_id.clone(), rows_imported, total_rows })
+    Ok(import_summary(&request.import_id, rows_imported, total_rows, started_at))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::models::connection::DatabaseType;
+    use crate::models::connection::{ConnectionConfig, DatabaseType};
+    use crate::storage::Storage;
     use crate::xlsx_export::{build_xlsx_workbook_multi, XlsxWorksheetData};
     use std::io::{Cursor, Write};
 
+    fn xlsx_named_spill_files() -> std::collections::HashSet<std::path::PathBuf> {
+        std::fs::read_dir(std::env::temp_dir())
+            .into_iter()
+            .flatten()
+            .flatten()
+            .filter(|entry| entry.file_name().to_string_lossy().starts_with("dbx-xlsx-shared-"))
+            .map(|entry| entry.path())
+            .collect()
+    }
+
+    #[test]
+    fn table_import_progress_and_summary_report_elapsed_ms() {
+        let started_at = std::time::Instant::now() - std::time::Duration::from_millis(25);
+
+        let progress = import_progress("import-1", TableImportStatus::Running, 10, 20, started_at, None);
+        let summary = import_summary("import-1", 20, 20, started_at);
+        let progress_json = serde_json::to_value(&progress).unwrap();
+        let summary_json = serde_json::to_value(&summary).unwrap();
+
+        assert!(progress.elapsed_ms >= 25);
+        assert!(summary.elapsed_ms >= progress.elapsed_ms);
+        assert_eq!(progress_json["elapsedMs"], serde_json::json!(progress.elapsed_ms));
+        assert_eq!(summary_json["elapsedMs"], serde_json::json!(summary.elapsed_ms));
+        assert_eq!(progress_json["phase"], serde_json::json!("writing"));
+        assert_eq!(progress_json["totalRowsExact"], serde_json::json!(true));
+    }
+
+    #[test]
+    fn compiled_import_plan_reuses_source_indexes_and_target_types() {
+        let columns = vec!["name".to_string(), "id".to_string()];
+        let mappings = vec![
+            TableImportColumnMapping {
+                source_column: "id".to_string(),
+                target_column: "user_id".to_string(),
+                target_data_type: None,
+            },
+            TableImportColumnMapping {
+                source_column: "name".to_string(),
+                target_column: "display_name".to_string(),
+                target_data_type: None,
+            },
+        ];
+
+        let plan = compile_import_plan(
+            &columns,
+            &mappings,
+            &[("DISPLAY_NAME".to_string(), "VARCHAR(255)".to_string()), ("user_id".to_string(), "BIGINT".to_string())],
+        )
+        .unwrap();
+
+        assert_eq!(plan.mapped_source_indexes, vec![1, 0]);
+        assert_eq!(plan.target_columns, vec!["user_id", "display_name"]);
+        assert_eq!(plan.column_types, vec![Some("BIGINT".to_string()), Some("VARCHAR(255)".to_string())]);
+    }
+
+    #[test]
+    fn prepared_import_source_is_reused_only_while_fingerprint_matches() {
+        let legacy_prepared: TableImportPreparedSource = serde_json::from_value(serde_json::json!({
+            "fingerprint": "legacy",
+            "columns": ["id"],
+            "rows": [[1]],
+            "totalRows": 1
+        }))
+        .unwrap();
+        assert!(legacy_prepared.total_rows_exact);
+
+        let path = std::env::temp_dir().join(format!("dbx-table-import-prepared-{}.csv", uuid::Uuid::new_v4()));
+        std::fs::write(&path, b"id,name\n1,Ada\n").unwrap();
+        let file_path = path.to_string_lossy().to_string();
+        let parse_options = TableImportParseOptions::default();
+        let fingerprint = import_source_fingerprint(&file_path, TableImportSourceFormat::Csv, &parse_options).unwrap();
+        let request = TableImportRequest {
+            import_id: "import-1".to_string(),
+            connection_id: "connection-1".to_string(),
+            database: "db".to_string(),
+            schema: "public".to_string(),
+            table: "users".to_string(),
+            file_path: file_path.clone(),
+            source_ref: None,
+            source_format: Some(TableImportSourceFormat::Csv),
+            parse_options,
+            mappings: vec![],
+            mode: TableImportMode::Append,
+            create_table: false,
+            batch_size: 500,
+            date_time_format: None,
+            prepared_source: Some(TableImportPreparedSource {
+                fingerprint,
+                columns: vec!["id".to_string(), "name".to_string()],
+                rows: vec![vec![serde_json::json!(1), serde_json::json!("Ada")]],
+                total_rows: 1,
+                total_rows_exact: true,
+                effective_encoding: Some(TableImportTextEncoding::Utf8),
+            }),
+            retain_source: false,
+        };
+
+        let prepared = validated_prepared_import_source(&request, TableImportSourceFormat::Csv).unwrap();
+        assert_eq!(prepared.total_rows, 1);
+        assert_eq!(prepared.columns, vec!["id", "name"]);
+
+        std::fs::write(&path, b"id,name\n1,Ada\n2,Grace\n").unwrap();
+        assert!(validated_prepared_import_source(&request, TableImportSourceFormat::Csv).is_none());
+        let _ = std::fs::remove_file(path);
+    }
+
     fn write_xlsx_test_entry<W: Write + std::io::Seek>(zip: &mut zip::ZipWriter<W>, path: &str, content: &str) {
         let options = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);
         zip.start_file(path, options).unwrap();
@@ -2625,6 +5174,63 @@ mod tests {
         zip.finish().unwrap().into_inner()
     }
 
+    fn build_preview_test_xlsx(sheet_xml: &str, shared_strings_xml: Option<&str>) -> Vec<u8> {
+        let cursor = Cursor::new(Vec::new());
+        let mut zip = zip::ZipWriter::new(cursor);
+        write_xlsx_test_entry(
+            &mut zip,
+            "[Content_Types].xml",
+            r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/>
+  <Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/>
+  <Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>
+  <Override PartName="/xl/sharedStrings.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml"/>
+</Types>"#,
+        );
+        write_xlsx_test_entry(
+            &mut zip,
+            "_rels/.rels",
+            r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+</Relationships>"#,
+        );
+        write_xlsx_test_entry(
+            &mut zip,
+            "xl/workbook.xml",
+            r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets>
+</workbook>"#,
+        );
+        write_xlsx_test_entry(
+            &mut zip,
+            "xl/_rels/workbook.xml.rels",
+            r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
+  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>
+</Relationships>"#,
+        );
+        write_xlsx_test_entry(
+            &mut zip,
+            "xl/styles.xml",
+            r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <cellXfs count="1"><xf numFmtId="0"/></cellXfs>
+</styleSheet>"#,
+        );
+        if let Some(shared_strings_xml) = shared_strings_xml {
+            write_xlsx_test_entry(&mut zip, "xl/sharedStrings.xml", shared_strings_xml);
+        }
+        write_xlsx_test_entry(&mut zip, "xl/worksheets/sheet1.xml", sheet_xml);
+        zip.finish().unwrap().into_inner()
+    }
+
     #[test]
     fn retains_only_temporal_and_text_target_xlsx_styles() {
         let styles = vec![
@@ -2807,6 +5413,62 @@ mod tests {
         assert_eq!(parsed.rows[1], vec![serde_json::json!("2"), serde_json::json!("上海")]);
     }
 
+    #[test]
+    fn file_encoding_detection_validates_utf8_and_gbk_in_one_monotonic_scan() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-encoding-{}.csv", uuid::Uuid::new_v4()));
+        let bytes = b"id,name\n1,\xD6\xD0\n";
+        std::fs::write(&path, bytes).unwrap();
+        let mut progress = Vec::new();
+
+        let (encoding, bom_len) =
+            auto_detect_text_encoding_from_file_with_progress(&path.to_string_lossy(), |bytes_read| {
+                progress.push(bytes_read)
+            })
+            .unwrap();
+
+        assert_eq!(encoding, TableImportTextEncoding::Gbk);
+        assert_eq!(bom_len, 0);
+        assert_eq!(progress.last().copied(), Some(bytes.len() as u64));
+        assert!(progress.windows(2).all(|window| window[0] <= window[1]));
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn explicit_encoding_validation_rejects_invalid_tail_before_import() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-invalid-tail-{}.csv", uuid::Uuid::new_v4()));
+        std::fs::write(&path, b"id\n1\n\xFF").unwrap();
+
+        let error = validate_text_encoding_from_file_with_progress(
+            &path.to_string_lossy(),
+            TableImportTextEncoding::Utf8,
+            0,
+            |_| {},
+        )
+        .unwrap_err();
+
+        assert!(error.contains("Invalid byte sequence for UTF-8"));
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn bom_encoding_detection_reports_the_file_as_fully_detected() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-bom-progress-{}.csv", uuid::Uuid::new_v4()));
+        let bytes = b"\xEF\xBB\xBFid,name\n1,Ada\n";
+        std::fs::write(&path, bytes).unwrap();
+        let mut progress = Vec::new();
+
+        let (encoding, bom_len) =
+            auto_detect_text_encoding_from_file_with_progress(&path.to_string_lossy(), |bytes_read| {
+                progress.push(bytes_read)
+            })
+            .unwrap();
+
+        assert_eq!(encoding, TableImportTextEncoding::Utf8);
+        assert_eq!(bom_len, 3);
+        assert_eq!(progress, vec![bytes.len() as u64]);
+        let _ = std::fs::remove_file(path);
+    }
+
     #[test]
     fn explicit_utf8_rejects_gbk_csv_without_replacing_data() {
         let (bytes, _, had_errors) = encoding_rs::GBK.encode("id,name\n1,中文\n");
@@ -2931,9 +5593,92 @@ mod tests {
         assert_eq!(preview.effective_encoding, Some(TableImportTextEncoding::Gbk));
         assert_eq!(preview.columns, vec!["编号", "城市"]);
         assert_eq!(preview.total_rows, 2);
+        assert!(!preview.total_rows_exact);
         assert_eq!(preview.rows[0], vec![serde_json::json!("1"), serde_json::json!("北京")]);
     }
 
+    #[test]
+    fn bounded_csv_preview_does_not_parse_the_tail() {
+        let reader = csv::ReaderBuilder::new()
+            .has_headers(false)
+            .flexible(true)
+            .from_reader(&b"id,name\n1,Ada\n\"unterminated"[..]);
+        let config =
+            effective_delimited_config(TableImportSourceFormat::Csv, &TableImportParseOptions::default()).unwrap();
+
+        let preview = parse_csv_reader_bounded(reader, config, 1, TableImportTextEncoding::Utf8).unwrap();
+
+        assert_eq!(preview.columns, vec!["id", "name"]);
+        assert_eq!(preview.rows, vec![vec![serde_json::json!("1"), serde_json::json!("Ada")]]);
+        assert_eq!(preview.total_rows, 1);
+    }
+
+    #[test]
+    fn streams_delimited_rows_in_batches_and_preserves_selected_range() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-stream-{}.csv", uuid::Uuid::new_v4()));
+        let bytes = b"report,ignored\nid,name\nnotes,ignored\n1,Ada\n2,Grace\n3,Linus\nsummary,3\n";
+        std::fs::write(&path, bytes).unwrap();
+        let options = TableImportParseOptions {
+            encoding: Some(TableImportTextEncoding::Utf8),
+            title_row: Some(2),
+            data_start_row: Some(4),
+            last_data_row: Some(6),
+            ..TableImportParseOptions::default()
+        };
+        let (sender, mut receiver) = tokio::sync::mpsc::channel(16);
+
+        stream_delimited_rows_to_channel(&path.to_string_lossy(), TableImportSourceFormat::Csv, &options, 2, sender)
+            .unwrap();
+
+        let messages =
+            std::iter::from_fn(|| receiver.blocking_recv()).map(|message| message.unwrap()).collect::<Vec<_>>();
+        assert!(
+            matches!(messages.first(), Some(DelimitedStreamMessage::Header(columns)) if columns == &vec!["id".to_string(), "name".to_string()])
+        );
+        assert!(matches!(messages.last(), Some(DelimitedStreamMessage::Done)));
+        let batches = messages
+            .iter()
+            .filter_map(|message| match message {
+                DelimitedStreamMessage::Rows { rows, .. } => Some(rows),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        assert_eq!(batches.len(), 2);
+        assert_eq!(
+            batches[0],
+            &vec![
+                vec![serde_json::json!("1"), serde_json::json!("Ada")],
+                vec![serde_json::json!("2"), serde_json::json!("Grace")],
+            ]
+        );
+        assert_eq!(batches[1], &vec![vec![serde_json::json!("3"), serde_json::json!("Linus")]]);
+        let bytes_read = messages
+            .iter()
+            .filter_map(|message| match message {
+                DelimitedStreamMessage::Rows { bytes_read, .. } => Some(*bytes_read),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+        assert!(bytes_read.windows(2).all(|window| window[0] <= window[1]));
+        assert!(bytes_read.last().copied().unwrap_or_default() <= bytes.len() as u64);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn legacy_xls_uses_a_stricter_non_streaming_file_limit() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-limit-{}.xls", uuid::Uuid::new_v4()));
+        let file = File::create(&path).unwrap();
+        file.set_len(MAX_LEGACY_XLS_IMPORT_BYTES + 1).unwrap();
+        drop(file);
+
+        let error =
+            ensure_non_streaming_file_size(&path.to_string_lossy(), TableImportSourceFormat::Excel).unwrap_err();
+
+        assert!(error.contains(&MAX_LEGACY_XLS_IMPORT_BYTES.to_string()));
+        ensure_non_streaming_file_size(&path.to_string_lossy(), TableImportSourceFormat::Json).unwrap();
+        let _ = std::fs::remove_file(path);
+    }
+
     #[test]
     fn parses_tsv_with_tab_delimiter() {
         let parsed = parse_delimited_bytes(b"id\tname\n1\tAda\n", b'\t', 10).unwrap();
@@ -3075,6 +5820,733 @@ mod tests {
         let _ = std::fs::remove_file(path);
     }
 
+    #[test]
+    fn fast_excel_preview_reads_only_requested_rows_and_reuses_sheet_metadata() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-preview-{}.xlsx", uuid::Uuid::new_v4()));
+        let workbook = build_xlsx_workbook_multi(&[
+            XlsxWorksheetData {
+                sheet_name: Some("First".to_string()),
+                columns: vec!["id".to_string()],
+                column_types: vec![],
+                rows: vec![vec![serde_json::json!(1)]],
+            },
+            XlsxWorksheetData {
+                sheet_name: Some("Second".to_string()),
+                columns: vec!["name".to_string()],
+                column_types: vec![],
+                rows: vec![vec![serde_json::json!("Ada")], vec![serde_json::json!("Grace")]],
+            },
+        ])
+        .unwrap();
+        std::fs::write(&path, workbook).unwrap();
+        let options =
+            TableImportParseOptions { sheet_name: Some("Second".to_string()), ..TableImportParseOptions::default() };
+
+        let (preview, sheets) = parse_xlsx_preview_file_with_options(&path.to_string_lossy(), &options, 1).unwrap();
+
+        assert_eq!(sheets, vec!["First", "Second"]);
+        assert_eq!(preview.columns, vec!["name"]);
+        assert_eq!(preview.rows, vec![vec![serde_json::json!("Ada")]]);
+        assert_eq!(preview.total_rows, 1);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn xlsx_shared_strings_use_disk_index_above_memory_limit() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-shared-index-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:A2"/>
+  <sheetData><row r="1"><c r="A1" t="s"><v>0</v></c></row><row r="2"><c r="A2" t="s"><v>1</v></c></row></sheetData>
+</worksheet>"#;
+        let shared_strings_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="2" uniqueCount="2">
+  <si><t>name</t></si><si><r><t>Ada</t></r><rPh sb="0" eb="3"><t>ignored</t></rPh></si>
+</sst>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, Some(shared_strings_xml))).unwrap();
+        let mut zip = zip::ZipArchive::new(File::open(&path).unwrap()).unwrap();
+
+        let mut strings = open_xlsx_shared_strings(&mut zip, 0).unwrap();
+        assert!(strings.disk_files().is_some(), "disk-backed shared strings");
+        assert_eq!(strings.get(0).unwrap().as_deref(), Some("name"));
+        assert_eq!(strings.get(1).unwrap().as_deref(), Some("Ada"));
+        drop(strings);
+        drop(zip);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn xlsx_disk_shared_strings_do_not_leave_named_spill_files() {
+        let path =
+            std::env::temp_dir().join(format!("dbx-table-import-shared-anonymous-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:A1"/>
+  <sheetData><row r="1"><c r="A1" t="s"><v>0</v></c></row></sheetData>
+</worksheet>"#;
+        let shared_strings_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="1" uniqueCount="1">
+  <si><t>sensitive-value</t></si>
+</sst>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, Some(shared_strings_xml))).unwrap();
+        let mut zip = zip::ZipArchive::new(File::open(&path).unwrap()).unwrap();
+        let before = xlsx_named_spill_files();
+
+        let strings = open_xlsx_shared_strings(&mut zip, 0).unwrap();
+        let named_spill_files: Vec<_> = xlsx_named_spill_files().difference(&before).cloned().collect();
+
+        drop(strings);
+        drop(zip);
+        let _ = std::fs::remove_file(path);
+        let remaining_spill_files: Vec<_> = xlsx_named_spill_files().difference(&before).cloned().collect();
+        assert!(
+            named_spill_files.is_empty(),
+            "disk-backed shared strings created named spill files: {named_spill_files:?}"
+        );
+        assert!(
+            remaining_spill_files.is_empty(),
+            "disk-backed shared strings left named spill files: {remaining_spill_files:?}"
+        );
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn xlsx_disk_shared_strings_are_owner_only() {
+        use std::os::unix::fs::PermissionsExt;
+
+        let path = std::env::temp_dir().join(format!("dbx-table-import-shared-perms-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:A2"/>
+  <sheetData><row r="1"><c r="A1" t="s"><v>0</v></c></row><row r="2"><c r="A2" t="s"><v>1</v></c></row></sheetData>
+</worksheet>"#;
+        let shared_strings_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="2" uniqueCount="2">
+  <si><t>name</t></si><si><t>Ada</t></si>
+</sst>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, Some(shared_strings_xml))).unwrap();
+        let mut zip = zip::ZipArchive::new(File::open(&path).unwrap()).unwrap();
+
+        let strings = open_xlsx_shared_strings(&mut zip, 0).unwrap();
+        let (data_file, index_file) = strings.disk_files().expect("disk-backed shared strings");
+
+        // Both spill files must be readable and writable only by the owner so other local
+        // users cannot read sensitive shared-string content while an import is in flight.
+        for spill_file in [data_file, index_file] {
+            let mode = spill_file.metadata().unwrap().permissions().mode() & 0o777;
+            assert_eq!(mode, 0o600, "unexpected shared-string spill-file mode: {mode:o}");
+        }
+
+        drop(strings);
+        drop(zip);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn xlsx_disk_shared_strings_are_cleaned_up_after_parse_failure() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-shared-fail-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:A1"/>
+  <sheetData><row r="1"><c r="A1" t="s"><v>0</v></c></row></sheetData>
+</worksheet>"#;
+        // Malformed XML: the reader spills the first string to disk, then errors on the
+        // broken markup, so the temp files must still be removed on the error path.
+        let shared_strings_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="2" uniqueCount="2">
+  <si><t>name</t></si><si><t>Ada</t></si> <<< broken"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, Some(shared_strings_xml))).unwrap();
+        let mut zip = zip::ZipArchive::new(File::open(&path).unwrap()).unwrap();
+
+        let before = xlsx_named_spill_files();
+        let result = open_xlsx_shared_strings(&mut zip, 0);
+        assert!(result.is_err(), "expected malformed shared strings to fail parsing");
+        let leaked: Vec<_> = xlsx_named_spill_files().difference(&before).cloned().collect();
+        assert!(leaked.is_empty(), "spill files leaked after parse failure: {leaked:?}");
+
+        drop(zip);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn streaming_excel_rows_avoid_materializing_the_full_range() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-stream-{}.xlsx", uuid::Uuid::new_v4()));
+        let workbook = build_xlsx_workbook_multi(&[XlsxWorksheetData {
+            sheet_name: Some("Rows".to_string()),
+            columns: vec!["id".to_string(), "name".to_string()],
+            column_types: vec![],
+            rows: vec![
+                vec![serde_json::json!(1), serde_json::json!("Ada")],
+                vec![serde_json::json!(2), serde_json::json!("Grace")],
+            ],
+        }])
+        .unwrap();
+        std::fs::write(&path, workbook).unwrap();
+        let (sender, mut receiver) = tokio::sync::mpsc::channel(16);
+
+        stream_xlsx_rows_to_channel(
+            &path.to_string_lossy(),
+            &TableImportParseOptions::default(),
+            1,
+            None,
+            HashSet::new(),
+            false,
+            sender,
+        )
+        .unwrap();
+
+        let mut messages = Vec::new();
+        while let Some(message) = receiver.blocking_recv() {
+            messages.push(message.unwrap());
+        }
+        assert!(
+            matches!(messages.first(), Some(XlsxStreamMessage::Header(columns)) if columns == &vec!["id".to_string(), "name".to_string()])
+        );
+        let streamed_rows = messages
+            .into_iter()
+            .filter_map(|message| match message {
+                XlsxStreamMessage::Rows(rows) => Some(rows),
+                _ => None,
+            })
+            .flatten()
+            .collect::<Vec<_>>();
+        assert_eq!(streamed_rows.len(), 2);
+        assert_eq!(streamed_rows[0], vec![serde_json::json!(1.0), serde_json::json!("Ada")]);
+        assert_eq!(streamed_rows[1], vec![serde_json::json!(2.0), serde_json::json!("Grace")]);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[tokio::test]
+    async fn truncate_xlsx_with_malformed_tail_preserves_existing_rows() {
+        let dir = tempfile::tempdir().unwrap();
+        let storage = Storage::open(&dir.path().join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let connection_id = "xlsx-truncate-tail";
+        let pool_key = format!("{connection_id}:session:import");
+        let database_path = dir.path().join("target.db");
+        let sqlite = crate::db::sqlite::connect_path_create_if_missing(database_path.to_str().unwrap()).await.unwrap();
+        crate::db::sqlite::execute_query(
+            &sqlite,
+            "CREATE TABLE items (id INTEGER, name TEXT); INSERT INTO items VALUES (999, 'old')",
+        )
+        .await
+        .unwrap();
+        state.connections.write().await.insert(pool_key.clone(), PoolKind::Sqlite(sqlite.clone()));
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": connection_id,
+            "name": "XLSX truncate tail test",
+            "db_type": "sqlite",
+            "host": "",
+            "port": 0,
+            "username": "",
+            "password": "",
+            "database": database_path.to_string_lossy()
+        }))
+        .unwrap();
+        state.configs.write().await.insert(connection_id.to_string(), config);
+
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:B4"/>
+  <sheetData>
+    <row r="1"><c r="A1" t="inlineStr"><is><t>id</t></is></c><c r="B1" t="inlineStr"><is><t>name</t></is></c></row>
+    <row r="2"><c r="A2"><v>1</v></c><c r="B2" t="inlineStr"><is><t>Ada</t></is></c></row>
+    <row r="3"><c r="A3"><v>2</v></c><c r="B3" t="inlineStr"><is><t>Grace</t></is></c></row>
+    <row r="4"><c r="A4"><v>3</v></c><c r="B4" t="inlineStr"><is><t>Linus</t></is></c></row>
+  </broken>
+</worksheet>"#;
+        let xlsx_path = dir.path().join("malformed-tail.xlsx");
+        std::fs::write(&xlsx_path, build_preview_test_xlsx(sheet_xml, None)).unwrap();
+        let request = TableImportRequest {
+            import_id: "malformed-tail".to_string(),
+            connection_id: connection_id.to_string(),
+            database: String::new(),
+            schema: String::new(),
+            table: "items".to_string(),
+            file_path: xlsx_path.to_string_lossy().to_string(),
+            source_ref: None,
+            source_format: Some(TableImportSourceFormat::Excel),
+            parse_options: TableImportParseOptions::default(),
+            mappings: vec![
+                TableImportColumnMapping {
+                    source_column: "id".to_string(),
+                    target_column: "id".to_string(),
+                    target_data_type: None,
+                },
+                TableImportColumnMapping {
+                    source_column: "name".to_string(),
+                    target_column: "name".to_string(),
+                    target_data_type: None,
+                },
+            ],
+            mode: TableImportMode::Truncate,
+            create_table: false,
+            batch_size: 1,
+            date_time_format: None,
+            prepared_source: None,
+            retain_source: false,
+        };
+
+        let error = import_table_file_core(
+            &state,
+            &request,
+            &DatabaseType::Sqlite,
+            &pool_key,
+            |_| Box::pin(async { false }),
+            |_| {},
+        )
+        .await
+        .unwrap_err();
+        assert!(!error.is_empty());
+
+        let rows =
+            crate::db::sqlite::execute_query(&sqlite, "SELECT id, name FROM items ORDER BY id").await.unwrap().rows;
+        assert_eq!(rows, vec![vec![serde_json::json!(999), serde_json::json!("old")]]);
+    }
+
+    #[tokio::test]
+    async fn cancelling_xlsx_after_validation_prevents_non_transactional_truncate() {
+        let dir = tempfile::tempdir().unwrap();
+        let storage = Storage::open(&dir.path().join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let connection_id = "cancel-xlsx-after-validation";
+        let pool_key = format!("{connection_id}:session:import");
+        let database_path = dir.path().join("target.db");
+        let sqlite = crate::db::sqlite::connect_path_create_if_missing(database_path.to_str().unwrap()).await.unwrap();
+        crate::db::sqlite::execute_query(
+            &sqlite,
+            "CREATE TABLE items (id INTEGER, name TEXT); INSERT INTO items VALUES (999, 'old')",
+        )
+        .await
+        .unwrap();
+        state.connections.write().await.insert(pool_key.clone(), PoolKind::Sqlite(sqlite.clone()));
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": connection_id,
+            "name": "Cancel XLSX validation test",
+            "db_type": "sqlite",
+            "host": "",
+            "port": 0,
+            "username": "",
+            "password": "",
+            "database": database_path.to_string_lossy()
+        }))
+        .unwrap();
+        state.configs.write().await.insert(connection_id.to_string(), config);
+
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <sheetData>
+    <row r="1"><c r="A1" t="inlineStr"><is><t>id</t></is></c><c r="B1" t="inlineStr"><is><t>name</t></is></c></row>
+    <row r="2"><c r="A2"><v>1</v></c><c r="B2" t="inlineStr"><is><t>Ada</t></is></c></row>
+  </sheetData>
+</worksheet>"#;
+        let xlsx_path = dir.path().join("cancel-after-validation.xlsx");
+        std::fs::write(&xlsx_path, build_preview_test_xlsx(sheet_xml, None)).unwrap();
+        let request = TableImportRequest {
+            import_id: "cancel-xlsx-after-validation".to_string(),
+            connection_id: connection_id.to_string(),
+            database: String::new(),
+            schema: String::new(),
+            table: "items".to_string(),
+            file_path: xlsx_path.to_string_lossy().to_string(),
+            source_ref: None,
+            source_format: Some(TableImportSourceFormat::Excel),
+            parse_options: TableImportParseOptions::default(),
+            mappings: vec![
+                TableImportColumnMapping {
+                    source_column: "id".to_string(),
+                    target_column: "id".to_string(),
+                    target_data_type: None,
+                },
+                TableImportColumnMapping {
+                    source_column: "name".to_string(),
+                    target_column: "name".to_string(),
+                    target_data_type: None,
+                },
+            ],
+            mode: TableImportMode::Truncate,
+            create_table: false,
+            batch_size: 1,
+            date_time_format: None,
+            prepared_source: None,
+            retain_source: false,
+        };
+
+        let error = import_table_file_core(
+            &state,
+            &request,
+            &DatabaseType::Mysql,
+            &pool_key,
+            |_| Box::pin(async { true }),
+            |_| {},
+        )
+        .await
+        .unwrap_err();
+        assert_eq!(error, "Import cancelled");
+
+        let rows = crate::db::sqlite::execute_query(&sqlite, "SELECT id, name FROM items").await.unwrap().rows;
+        assert_eq!(rows, vec![vec![serde_json::json!(999), serde_json::json!("old")]]);
+    }
+
+    #[tokio::test]
+    async fn cancelling_before_first_truncate_batch_preserves_existing_rows() {
+        let dir = tempfile::tempdir().unwrap();
+        let storage = Storage::open(&dir.path().join("storage.db")).await.unwrap();
+        let state = AppState::new(storage);
+        let connection_id = "cancel-truncate-first-batch";
+        let pool_key = format!("{connection_id}:session:import");
+        let database_path = dir.path().join("target.db");
+        let sqlite = crate::db::sqlite::connect_path_create_if_missing(database_path.to_str().unwrap()).await.unwrap();
+        crate::db::sqlite::execute_query(
+            &sqlite,
+            "CREATE TABLE items (id INTEGER, name TEXT); INSERT INTO items VALUES (999, 'old')",
+        )
+        .await
+        .unwrap();
+        state.connections.write().await.insert(pool_key.clone(), PoolKind::Sqlite(sqlite.clone()));
+        let config: ConnectionConfig = serde_json::from_value(serde_json::json!({
+            "id": connection_id,
+            "name": "Cancel truncate first batch test",
+            "db_type": "sqlite",
+            "host": "",
+            "port": 0,
+            "username": "",
+            "password": "",
+            "database": database_path.to_string_lossy()
+        }))
+        .unwrap();
+        state.configs.write().await.insert(connection_id.to_string(), config);
+        let csv_path = dir.path().join("rows.csv");
+        std::fs::write(&csv_path, b"id,name\n1,Ada\n2,Grace\n").unwrap();
+        let request = TableImportRequest {
+            import_id: "cancel-before-first-batch".to_string(),
+            connection_id: connection_id.to_string(),
+            database: String::new(),
+            schema: String::new(),
+            table: "items".to_string(),
+            file_path: csv_path.to_string_lossy().to_string(),
+            source_ref: None,
+            source_format: Some(TableImportSourceFormat::Csv),
+            parse_options: TableImportParseOptions::default(),
+            mappings: vec![
+                TableImportColumnMapping {
+                    source_column: "id".to_string(),
+                    target_column: "id".to_string(),
+                    target_data_type: None,
+                },
+                TableImportColumnMapping {
+                    source_column: "name".to_string(),
+                    target_column: "name".to_string(),
+                    target_data_type: None,
+                },
+            ],
+            mode: TableImportMode::Truncate,
+            create_table: false,
+            batch_size: 1,
+            date_time_format: None,
+            prepared_source: None,
+            retain_source: false,
+        };
+
+        let error = import_table_file_core(
+            &state,
+            &request,
+            &DatabaseType::Sqlite,
+            &pool_key,
+            |_| Box::pin(async { true }),
+            |_| {},
+        )
+        .await
+        .unwrap_err();
+        assert_eq!(error, "Import cancelled");
+
+        let rows = crate::db::sqlite::execute_query(&sqlite, "SELECT id, name FROM items").await.unwrap().rows;
+        assert_eq!(rows, vec![vec![serde_json::json!(999), serde_json::json!("old")]]);
+    }
+
+    #[test]
+    fn streaming_excel_rows_preserve_offset_ranges_and_temporal_styles() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-stream-offset-{}.xlsx", uuid::Uuid::new_v4()));
+        std::fs::write(&path, build_styled_test_xlsx(false, &[("C3", 1, 45996.0), ("D3", 2, 45996.0)])).unwrap();
+        let options = TableImportParseOptions { has_header: Some(false), ..TableImportParseOptions::default() };
+        let (sender, mut receiver) = tokio::sync::mpsc::channel(16);
+
+        stream_xlsx_rows_to_channel(
+            &path.to_string_lossy(),
+            &options,
+            500,
+            Some(vec!["column_1".to_string(), "column_2".to_string()]),
+            HashSet::new(),
+            false,
+            sender,
+        )
+        .unwrap();
+
+        let mut streamed_rows = Vec::new();
+        while let Some(message) = receiver.blocking_recv() {
+            if let XlsxStreamMessage::Rows(rows) = message.unwrap() {
+                streamed_rows.extend(rows);
+            }
+        }
+        assert_eq!(
+            streamed_rows,
+            vec![vec![serde_json::json!("2025-12-05"), serde_json::json!("2025-12-05 00:00:00")]]
+        );
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn streaming_excel_rows_preserve_numeric_display_text_for_text_targets() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-stream-format-{}.xlsx", uuid::Uuid::new_v4()));
+        std::fs::write(&path, build_styled_test_xlsx(false, &[("A1", 5, 10.0)])).unwrap();
+        let options = TableImportParseOptions { has_header: Some(false), ..TableImportParseOptions::default() };
+        let (sender, mut receiver) = tokio::sync::mpsc::channel(16);
+
+        stream_xlsx_rows_to_channel(
+            &path.to_string_lossy(),
+            &options,
+            500,
+            Some(vec!["column_1".to_string()]),
+            HashSet::from(["column_1".to_string()]),
+            false,
+            sender,
+        )
+        .unwrap();
+
+        let mut streamed_rows = Vec::new();
+        while let Some(message) = receiver.blocking_recv() {
+            if let XlsxStreamMessage::Rows(rows) = message.unwrap() {
+                streamed_rows.extend(rows);
+            }
+        }
+        assert_eq!(streamed_rows, vec![vec![serde_json::json!("10.0")]]);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn streaming_excel_rows_preserve_custom_title_and_data_range() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-stream-range-{}.xlsx", uuid::Uuid::new_v4()));
+        let workbook = build_xlsx_workbook_multi(&[XlsxWorksheetData {
+            sheet_name: Some("Rows".to_string()),
+            columns: vec!["report".to_string(), "ignored".to_string()],
+            column_types: vec![],
+            rows: vec![
+                vec![serde_json::json!("id"), serde_json::json!("name")],
+                vec![serde_json::json!(1), serde_json::json!("Ada")],
+                vec![serde_json::json!(2), serde_json::json!("Grace")],
+                vec![serde_json::json!("summary"), serde_json::json!(2)],
+            ],
+        }])
+        .unwrap();
+        std::fs::write(&path, workbook).unwrap();
+        let options = TableImportParseOptions {
+            title_row: Some(2),
+            data_start_row: Some(3),
+            last_data_row: Some(4),
+            ..TableImportParseOptions::default()
+        };
+        let (sender, mut receiver) = tokio::sync::mpsc::channel(16);
+
+        stream_xlsx_rows_to_channel(&path.to_string_lossy(), &options, 500, None, HashSet::new(), false, sender)
+            .unwrap();
+
+        let mut columns = Vec::new();
+        let mut streamed_rows = Vec::new();
+        while let Some(message) = receiver.blocking_recv() {
+            match message.unwrap() {
+                XlsxStreamMessage::Header(header) => columns = header,
+                XlsxStreamMessage::Rows(rows) => streamed_rows.extend(rows),
+                _ => {}
+            }
+        }
+        assert_eq!(columns, vec!["id", "name"]);
+        assert_eq!(
+            streamed_rows,
+            vec![
+                vec![serde_json::json!(1.0), serde_json::json!("Ada")],
+                vec![serde_json::json!(2.0), serde_json::json!("Grace")],
+            ]
+        );
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn streaming_excel_rows_reject_data_beyond_preview_columns() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-stream-wide-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:B2"/>
+  <sheetData>
+    <row r="1"><c r="A1" t="inlineStr"><is><t>id</t></is></c></row>
+    <row r="2"><c r="A2"><v>7</v></c><c r="B2" t="inlineStr"><is><t>unexpected</t></is></c></row>
+  </sheetData>
+</worksheet>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, None)).unwrap();
+        let (sender, _receiver) = tokio::sync::mpsc::channel(16);
+
+        let error = stream_xlsx_rows_to_channel(
+            &path.to_string_lossy(),
+            &TableImportParseOptions::default(),
+            500,
+            Some(vec!["id".to_string()]),
+            HashSet::new(),
+            false,
+            sender,
+        )
+        .unwrap_err();
+
+        assert!(error.contains("beyond the 1 columns confirmed by the preview"));
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn streaming_excel_rows_accept_sparse_empty_cells() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-stream-sparse-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:C2"/>
+  <sheetData>
+    <row r="1"><c r="A1" t="inlineStr"><is><t>id</t></is></c><c r="B1"/><c r="C1" t="inlineStr"><is><t>name</t></is></c></row>
+    <row r="2"><c r="A2"><v>7</v></c><c r="B2"/><c r="C2" t="inlineStr"><is><t>Ada</t></is></c></row>
+  </sheetData>
+</worksheet>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, None)).unwrap();
+        let (sender, mut receiver) = tokio::sync::mpsc::channel(16);
+
+        stream_xlsx_rows_to_channel(
+            &path.to_string_lossy(),
+            &TableImportParseOptions::default(),
+            500,
+            None,
+            HashSet::new(),
+            false,
+            sender,
+        )
+        .unwrap();
+
+        let mut streamed_rows = Vec::new();
+        while let Some(message) = receiver.blocking_recv() {
+            if let XlsxStreamMessage::Rows(rows) = message.unwrap() {
+                streamed_rows.extend(rows);
+            }
+        }
+        assert_eq!(
+            streamed_rows,
+            vec![vec![serde_json::json!(7.0), serde_json::Value::Null, serde_json::json!("Ada")]]
+        );
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn fast_excel_preview_matches_calamine_when_row_and_cell_references_are_omitted() {
+        let path =
+            std::env::temp_dir().join(format!("dbx-table-import-preview-implicit-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:B2"/>
+  <sheetData>
+    <row><c t="inlineStr"><is><t>id</t></is></c><c t="inlineStr"><is><t>name</t></is></c></row>
+    <row><c><v>7</v></c><c t="inlineStr"><is><t>Ada</t></is></c></row>
+  </sheetData>
+</worksheet>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, None)).unwrap();
+
+        let parsed =
+            parse_xlsx_file_with_options(&path.to_string_lossy(), &TableImportParseOptions::default(), 10).unwrap();
+        let (preview, _) =
+            parse_xlsx_preview_file_with_options(&path.to_string_lossy(), &TableImportParseOptions::default(), 10)
+                .unwrap();
+
+        assert_eq!(preview.columns, parsed.columns);
+        assert_eq!(preview.rows, parsed.rows);
+        assert_eq!(preview.rows, vec![vec![serde_json::json!(7.0), serde_json::json!("Ada")]]);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn fast_excel_preview_advances_past_empty_cells_with_implicit_references() {
+        let path =
+            std::env::temp_dir().join(format!("dbx-table-import-preview-empty-cell-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:C2"/>
+  <sheetData>
+    <row><c t="inlineStr"><is><t>id</t></is></c><c/><c t="inlineStr"><is><t>name</t></is></c></row>
+    <row><c><v>7</v></c><c/><c t="inlineStr"><is><t>Ada</t></is></c></row>
+  </sheetData>
+</worksheet>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, None)).unwrap();
+
+        let parsed =
+            parse_xlsx_file_with_options(&path.to_string_lossy(), &TableImportParseOptions::default(), 10).unwrap();
+        let (preview, _) =
+            parse_xlsx_preview_file_with_options(&path.to_string_lossy(), &TableImportParseOptions::default(), 10)
+                .unwrap();
+
+        assert_eq!(preview.columns, parsed.columns);
+        assert_eq!(preview.rows, parsed.rows);
+        assert_eq!(preview.columns, vec!["id", "column_2", "name"]);
+        assert_eq!(preview.rows, vec![vec![serde_json::json!(7.0), serde_json::Value::Null, serde_json::json!("Ada")]]);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn fast_excel_preview_excludes_phonetic_runs_from_shared_and_inline_strings() {
+        let path =
+            std::env::temp_dir().join(format!("dbx-table-import-preview-phonetic-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:B2"/>
+  <sheetData>
+    <row r="1"><c r="A1" t="s"><v>0</v></c><c r="B1" t="inlineStr"><is><t>inline</t></is></c></row>
+    <row r="2"><c r="A2" t="s"><v>1</v></c><c r="B2" t="inlineStr"><is><r><t>大阪</t></r><rPh sb="0" eb="2"><t>おおさか</t></rPh></is></c></row>
+  </sheetData>
+</worksheet>"#;
+        let shared_strings_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="2" uniqueCount="2">
+  <si><t>shared</t></si>
+  <si><r><t>東京</t></r><rPh sb="0" eb="2"><t>とうきょう</t></rPh></si>
+</sst>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, Some(shared_strings_xml))).unwrap();
+
+        let parsed =
+            parse_xlsx_file_with_options(&path.to_string_lossy(), &TableImportParseOptions::default(), 10).unwrap();
+        let (preview, _) =
+            parse_xlsx_preview_file_with_options(&path.to_string_lossy(), &TableImportParseOptions::default(), 10)
+                .unwrap();
+
+        assert_eq!(preview.rows, parsed.rows);
+        assert_eq!(preview.rows, vec![vec![serde_json::json!("東京"), serde_json::json!("大阪")]]);
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn fast_excel_preview_ignores_stale_and_overwide_dimensions() {
+        let path =
+            std::env::temp_dir().join(format!("dbx-table-import-preview-dimension-{}.xlsx", uuid::Uuid::new_v4()));
+        let sheet_xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <dimension ref="A1:XFD1048576"/>
+  <sheetData>
+    <row r="100"><c r="A100" t="inlineStr"><is><t>id</t></is></c><c r="B100" t="inlineStr"><is><t>name</t></is></c></row>
+    <row r="101"><c r="A101"><v>8</v></c><c r="B101" t="inlineStr"><is><t>Grace</t></is></c></row>
+  </sheetData>
+</worksheet>"#;
+        std::fs::write(&path, build_preview_test_xlsx(sheet_xml, None)).unwrap();
+
+        let parsed =
+            parse_xlsx_file_with_options(&path.to_string_lossy(), &TableImportParseOptions::default(), 10).unwrap();
+        let (preview, _) =
+            parse_xlsx_preview_file_with_options(&path.to_string_lossy(), &TableImportParseOptions::default(), 10)
+                .unwrap();
+
+        assert_eq!(preview.columns, parsed.columns);
+        assert_eq!(preview.rows, parsed.rows);
+        assert_eq!(preview.columns, vec!["id", "name"]);
+        assert_eq!(preview.rows, vec![vec![serde_json::json!(8.0), serde_json::json!("Grace")]]);
+        let _ = std::fs::remove_file(path);
+    }
+
     #[test]
     fn formats_unclassified_excel_datetimes_conservatively() {
         let date_cell = Data::DateTime(ExcelDateTime::new(45996.0, calamine::ExcelDateTimeType::DateTime, false));
@@ -3091,18 +6563,6 @@ mod tests {
         assert_eq!(infer_value_type(&time_value), Some(ImportInferredType::Decimal));
     }
 
-    #[test]
-    fn keeps_excel_numeric_and_text_cell_types_distinct() {
-        let integer_valued_float = xlsx_cell_value(&Data::Float(10_401_029_008.0));
-        assert_eq!(integer_valued_float, serde_json::json!(10_401_029_008.0));
-        assert_eq!(infer_value_type(&integer_valued_float), Some(ImportInferredType::Decimal));
-        assert_eq!(xlsx_cell_value(&Data::Float(10_401_029_008.5)), serde_json::json!(10_401_029_008.5));
-        assert_eq!(xlsx_cell_value(&Data::Float(9_007_199_254_740_992.0)), serde_json::json!(9_007_199_254_740_992.0));
-        for text in ["10.0", "00123", "1e3", "10401029008.0"] {
-            assert_eq!(xlsx_cell_value(&Data::String(text.to_string())), serde_json::json!(text));
-        }
-    }
-
     #[test]
     fn renders_common_excel_numeric_display_formats() {
         let display = |value, format_code: &str| {
@@ -3180,62 +6640,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn selects_excel_display_conversion_only_for_textual_mappings() {
-        let mappings = vec![
-            TableImportColumnMapping {
-                source_column: "code_source".to_string(),
-                target_column: "code".to_string(),
-                target_data_type: None,
-            },
-            TableImportColumnMapping {
-                source_column: "amount_source".to_string(),
-                target_column: "amount".to_string(),
-                target_data_type: None,
-            },
-        ];
-
-        let selected = textual_source_columns_for_import(
-            &mappings,
-            &[("code".to_string(), "varchar(32)".to_string()), ("amount".to_string(), "double".to_string())],
-        );
-
-        assert_eq!(selected, HashSet::from(["code_source".to_string()]));
-    }
-
-    #[test]
-    fn clickhouse_fixed_string_import_uses_excel_numeric_display_text() {
-        let path = std::env::temp_dir().join(format!("dbx-table-import-fixed-string-{}.xlsx", uuid::Uuid::new_v4()));
-        std::fs::write(&path, build_styled_test_xlsx(false, &[("A1", 5, 10.0)])).unwrap();
-        let options = TableImportParseOptions { has_header: Some(false), ..TableImportParseOptions::default() };
-        let mappings = vec![TableImportColumnMapping {
-            source_column: "column_1".to_string(),
-            target_column: "code".to_string(),
-            target_data_type: None,
-        }];
-        let target_column_types = [("code".to_string(), "FixedString(16)".to_string())];
-        let text_source_columns = textual_source_columns_for_import(&mappings, &target_column_types);
-
-        let data =
-            parse_xlsx_file_with_options_and_text_columns(&path.to_string_lossy(), &options, 10, &text_source_columns)
-                .unwrap();
-        let batches = build_import_insert_batches(
-            &data,
-            &mappings,
-            &target_column_types,
-            "issue_3683_fixed_string",
-            "",
-            &DatabaseType::ClickHouse,
-            500,
-        )
-        .unwrap();
-
-        assert_eq!(text_source_columns, HashSet::from(["column_1".to_string()]));
-        assert_eq!(data.rows, vec![vec![serde_json::json!("10.0")]]);
-        assert_eq!(batches[0].sql, "INSERT INTO `issue_3683_fixed_string` (`code`) VALUES\n('10.0')");
-        let _ = std::fs::remove_file(path);
-    }
-
     #[test]
     fn mysql_varchar_import_uses_excel_numeric_display_text() {
         let path = std::env::temp_dir().join(format!("dbx-table-import-number-format-{}.xlsx", uuid::Uuid::new_v4()));
@@ -3246,80 +6650,39 @@ mod tests {
         .unwrap();
         let options = TableImportParseOptions { has_header: Some(false), ..TableImportParseOptions::default() };
         let numeric_data = parse_xlsx_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
-        let mut data = parse_xlsx_file_with_options_and_text_columns(
+        let data = parse_xlsx_file_with_options_and_text_columns(
             &path.to_string_lossy(),
             &options,
             10,
             &HashSet::from(["column_1".to_string()]),
         )
         .unwrap();
-        data.rows.extend([
-            vec![serde_json::json!("10.0")],
-            vec![serde_json::json!("00123")],
-            vec![serde_json::json!("1e3")],
-            vec![serde_json::json!("10401029008.0")],
-        ]);
-        data.total_rows = data.rows.len();
-        let mappings = vec![TableImportColumnMapping {
-            source_column: "column_1".to_string(),
-            target_column: "code".to_string(),
-            target_data_type: None,
-        }];
-
-        let batches = build_import_insert_batches(
-            &data,
-            &mappings,
-            &[("code".to_string(), "varchar(32)".to_string())],
-            "issue_3683",
-            "",
-            &DatabaseType::Mysql,
-            500,
-        )
-        .unwrap();
 
         assert_eq!(
-            batches[0].sql,
-            "INSERT INTO `issue_3683` (`code`) VALUES\n('10401029008'),\n('10.0'),\n('10.00'),\n('10.0'),\n('00123'),\n('1e3'),\n('10401029008.0')"
+            data.rows,
+            vec![
+                vec![serde_json::json!("10401029008")],
+                vec![serde_json::json!("10.0")],
+                vec![serde_json::json!("10.00")],
+            ]
         );
-        assert!(data.rows[..3].iter().all(|row| row[0].as_str().is_some()));
         assert!(numeric_data.rows.iter().all(|row| row[0].as_f64().is_some()));
-
-        let numeric_batches = build_import_insert_batches(
-            &numeric_data,
-            &mappings,
-            &[("code".to_string(), "double".to_string())],
-            "issue_3683_numeric",
-            "",
-            &DatabaseType::Mysql,
-            500,
-        )
-        .unwrap();
-        assert!(numeric_batches[0].sql.contains("(10401029008.0),\n(10.0),\n(10.0)"));
         let _ = std::fs::remove_file(path);
     }
 
     #[test]
-    fn excel_integer_sample_keeps_decimal_create_table_inference() {
-        let path = std::env::temp_dir().join(format!("dbx-table-import-inference-{}.xlsx", uuid::Uuid::new_v4()));
-        let cells = (1..=101)
-            .map(|row| (format!("A{row}"), 0, if row == 101 { 100.5 } else { row as f64 }))
-            .collect::<Vec<_>>();
-        std::fs::write(&path, build_styled_test_xlsx(false, &cells)).unwrap();
-        let options = TableImportParseOptions { has_header: Some(false), ..TableImportParseOptions::default() };
-        let data =
-            parse_xlsx_file_with_options(&path.to_string_lossy(), &options, CREATE_TABLE_INFERENCE_ROWS).unwrap();
-        let mappings = vec![TableImportColumnMapping {
-            source_column: "column_1".to_string(),
-            target_column: "amount".to_string(),
-            target_data_type: None,
-        }];
+    fn borrowed_excel_cells_preserve_owned_cell_conversion_semantics() {
+        let shared_string = DataRef::SharedString("Ada");
+        let number = DataRef::Float(42.5);
+        let date = DataRef::DateTime(ExcelDateTime::new(45996.0, calamine::ExcelDateTimeType::DateTime, false));
 
-        let plan = build_import_create_table_plan(&data, &mappings, "measurements", "", &DatabaseType::Mysql).unwrap();
-
-        assert_eq!(data.total_rows, 101);
-        assert_eq!(data.rows.len(), CREATE_TABLE_INFERENCE_ROWS);
-        assert_eq!(plan.columns[0].data_type, "DOUBLE");
-        let _ = std::fs::remove_file(path);
+        assert_eq!(xlsx_cell_ref_label_with_temporal_kind(&shared_string, None), "Ada");
+        assert_eq!(xlsx_cell_ref_value_with_temporal_kind(&shared_string, None), serde_json::json!("Ada"));
+        assert_eq!(xlsx_cell_ref_value_with_temporal_kind(&number, None), serde_json::json!(42.5));
+        assert_eq!(
+            xlsx_cell_ref_value_with_temporal_kind(&date, Some(XlsxTemporalKind::Date)),
+            serde_json::json!("2025-12-05")
+        );
     }
 
     #[test]
@@ -3333,6 +6696,7 @@ mod tests {
         let options = TableImportParseOptions { has_header: Some(false), ..TableImportParseOptions::default() };
 
         let parsed = parse_xlsx_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
+        let (preview, _) = parse_xlsx_preview_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
 
         assert_eq!(parsed.columns, vec!["column_1", "column_2", "column_3", "column_4"]);
         assert_eq!(
@@ -3348,6 +6712,7 @@ mod tests {
         assert_eq!(infer_value_type(&parsed.rows[0][1]), Some(ImportInferredType::Timestamp));
         assert_eq!(infer_value_type(&parsed.rows[0][2]), Some(ImportInferredType::Text));
         assert_eq!(infer_value_type(&parsed.rows[0][3]), Some(ImportInferredType::Text));
+        assert_eq!(preview.rows, parsed.rows);
         let _ = std::fs::remove_file(path);
     }
 
@@ -3371,11 +6736,13 @@ mod tests {
         let options = TableImportParseOptions { has_header: Some(false), ..TableImportParseOptions::default() };
 
         let parsed = parse_xlsx_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
+        let (preview, _) = parse_xlsx_preview_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
 
         assert_eq!(parsed.columns, vec!["column_1", "column_2"]);
         assert_eq!(parsed.rows, vec![vec![serde_json::json!("2025-12-05"), serde_json::json!("2025-12-05 00:00:00")]]);
         assert_eq!(infer_value_type(&parsed.rows[0][0]), Some(ImportInferredType::Date));
         assert_eq!(infer_value_type(&parsed.rows[0][1]), Some(ImportInferredType::Timestamp));
+        assert_eq!(preview.rows, parsed.rows);
         let _ = std::fs::remove_file(path);
     }
 
@@ -3402,11 +6769,13 @@ mod tests {
             ..TableImportParseOptions::default()
         };
         let parsed = parse_xlsx_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
+        let (preview, _) = parse_xlsx_preview_file_with_options(&path.to_string_lossy(), &options, 10).unwrap();
 
         assert_eq!(parsed.columns, vec!["id", "name"]);
         assert_eq!(parsed.total_rows, 2);
         assert_eq!(parsed.rows[0], vec![serde_json::json!(1.0), serde_json::json!("Ada")]);
         assert_eq!(parsed.rows[1], vec![serde_json::json!(2.0), serde_json::json!("Grace")]);
+        assert_eq!(preview.rows, parsed.rows);
         let _ = std::fs::remove_file(path);
     }
 
@@ -3627,12 +6996,13 @@ mod tests {
     }
 
     #[test]
-    fn multi_row_insert_values_support_matches_database_dialects() {
-        assert!(!supports_multi_row_insert_values(&DatabaseType::Oracle));
-        assert!(!supports_multi_row_insert_values(&DatabaseType::OceanbaseOracle));
-        assert!(!supports_multi_row_insert_values(&DatabaseType::Iris));
-        assert!(supports_multi_row_insert_values(&DatabaseType::Postgres));
-        assert!(supports_multi_row_insert_values(&DatabaseType::Mysql));
+    fn import_batch_row_limits_match_database_dialects() {
+        assert_eq!(effective_import_batch_size(&DatabaseType::Oracle, 1000), 500);
+        assert_eq!(effective_import_batch_size(&DatabaseType::OceanbaseOracle, 1000), 1);
+        assert_eq!(effective_import_batch_size(&DatabaseType::Iris, 1000), 1);
+        assert_eq!(effective_import_batch_size(&DatabaseType::CloudflareD1, 1000), 100);
+        assert_eq!(effective_import_batch_size(&DatabaseType::Postgres, 1000), 1000);
+        assert_eq!(effective_import_batch_size(&DatabaseType::Mysql, 1000), 1000);
     }
 
     #[test]
@@ -3689,6 +7059,74 @@ mod tests {
         assert_eq!(batch.row_count, 1);
     }
 
+    #[test]
+    fn postgres_copy_text_batch_preserves_nulls_and_control_characters() {
+        let plan = CompiledImportPlan {
+            mapped_source_indexes: vec![0, 1],
+            target_columns: vec!["id".to_string(), "payload".to_string()],
+            column_types: vec![Some("integer".to_string()), Some("text".to_string())],
+        };
+        let (sql, data) = build_postgres_copy_text_batch(
+            &[
+                vec![serde_json::json!(1), serde_json::json!("a\\b\tline\nnext\u{000B}")],
+                vec![serde_json::Value::Null, serde_json::json!("\\N")],
+            ],
+            &plan,
+            "items",
+            "public",
+            None,
+        )
+        .unwrap();
+
+        assert_eq!(sql, "COPY \"public\".\"items\" (\"id\", \"payload\") FROM STDIN WITH (FORMAT text)");
+        assert_eq!(String::from_utf8(data).unwrap(), "1\ta\\\\b\\tline\\nnext\\v\n\\N\t\\\\N\n");
+    }
+
+    #[test]
+    fn postgres_copy_eligibility_requires_plain_table_without_rls_or_rules() {
+        assert_eq!(
+            postgres_copy_eligibility_sql("items", "public"),
+            "SELECT NOT c.relrowsecurity AND NOT c.relhasrules AS copy_eligible FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE n.nspname = 'public' AND c.relname = 'items' AND c.relkind IN ('r', 'p') LIMIT 1"
+        );
+        assert!(postgres_copy_eligibility_sql("items", "").contains("n.nspname = current_schema()"));
+    }
+
+    #[test]
+    fn postgres_truncate_first_batch_uses_transaction_without_copy() {
+        let policy = import_batch_execution_policy(&TableImportMode::Truncate, true, &DatabaseType::Postgres);
+
+        assert!(policy.transactional);
+        assert!(policy.include_truncate);
+        assert!(!policy.allow_postgres_copy);
+    }
+
+    #[test]
+    fn postgres_truncate_later_batches_are_transactional_and_allow_copy() {
+        let policy = import_batch_execution_policy(&TableImportMode::Truncate, false, &DatabaseType::Postgres);
+
+        assert!(policy.transactional);
+        assert!(!policy.include_truncate);
+        assert!(policy.allow_postgres_copy);
+    }
+
+    #[test]
+    fn append_batches_keep_the_existing_independent_execution_path() {
+        let policy = import_batch_execution_policy(&TableImportMode::Append, true, &DatabaseType::Postgres);
+
+        assert!(!policy.transactional);
+        assert!(!policy.include_truncate);
+        assert!(policy.allow_postgres_copy);
+    }
+
+    #[test]
+    fn truncate_keeps_native_non_transactional_drivers_on_the_existing_path() {
+        let policy = import_batch_execution_policy(&TableImportMode::Truncate, false, &DatabaseType::ClickHouse);
+
+        assert!(!policy.transactional);
+        assert!(!policy.include_truncate);
+        assert!(!policy.allow_postgres_copy);
+    }
+
     #[tokio::test]
     async fn preview_missing_source_fails_before_parsing() {
         let path = std::env::temp_dir().join(format!("dbx-missing-import-{}.csv", uuid::Uuid::new_v4()));
@@ -3706,7 +7144,7 @@ mod tests {
     }
 
     #[test]
-    fn oracle_import_insert_batches_use_single_row_statements() {
+    fn oracle_import_insert_batches_use_insert_all() {
         let mappings = vec![
             TableImportColumnMapping {
                 source_column: "id".to_string(),
@@ -3733,23 +7171,33 @@ mod tests {
         let batches =
             build_import_insert_batches(&data, &mappings, &[], "users", "HR", &DatabaseType::Oracle, 500).unwrap();
 
-        assert_eq!(
-            batches,
-            vec![
-                ImportSqlBatch {
-                    sql: "INSERT INTO \"HR\".\"users\" (\"id\", \"name\") VALUES\n(1, 'Ada')".to_string(),
-                    row_count: 1,
-                },
-                ImportSqlBatch {
-                    sql: "INSERT INTO \"HR\".\"users\" (\"id\", \"name\") VALUES\n(2, 'Grace')".to_string(),
-                    row_count: 1,
-                },
-                ImportSqlBatch {
-                    sql: "INSERT INTO \"HR\".\"users\" (\"id\", \"name\") VALUES\n(3, NULL)".to_string(),
-                    row_count: 1,
-                },
-            ]
-        );
+        assert_eq!(batches, vec![ImportSqlBatch {
+            sql: "INSERT ALL\nINTO \"HR\".\"users\" (\"id\", \"name\") VALUES (1, 'Ada')\nINTO \"HR\".\"users\" (\"id\", \"name\") VALUES (2, 'Grace')\nINTO \"HR\".\"users\" (\"id\", \"name\") VALUES (3, NULL)\nSELECT 1 FROM dual".to_string(),
+            row_count: 3,
+        }]);
+    }
+
+    #[test]
+    fn import_insert_batches_split_long_rows_by_sql_size() {
+        let mappings = vec![TableImportColumnMapping {
+            source_column: "payload".to_string(),
+            target_column: "payload".to_string(),
+            target_data_type: None,
+        }];
+        let data = ParsedImportFile {
+            columns: vec!["payload".to_string()],
+            rows: (0..4).map(|index| vec![serde_json::json!(format!("{index}{}", "x".repeat(180 * 1024)))]).collect(),
+            total_rows: 4,
+            effective_encoding: None,
+        };
+
+        let batches =
+            build_import_insert_batches(&data, &mappings, &[], "events", "public", &DatabaseType::Postgres, 500)
+                .unwrap();
+
+        assert!(batches.len() > 1);
+        assert_eq!(batches.iter().map(|batch| batch.row_count).sum::<usize>(), 4);
+        assert!(batches.iter().all(|batch| batch.sql.len() <= 512 * 1024));
     }
 
     #[test]
diff --git a/crates/dbx-core/src/task_supervisor.rs b/crates/dbx-core/src/task_supervisor.rs
index 76f145520d..aa344f3d19 100644
--- a/crates/dbx-core/src/task_supervisor.rs
+++ b/crates/dbx-core/src/task_supervisor.rs
@@ -27,17 +27,47 @@ impl TaskSupervisor {
         F: FnOnce(CancellationToken) -> Fut,
         Fut: Future<Output = ()> + Send + 'static,
     {
+        let key = key.into();
+        let mut tasks = self.tasks.lock().unwrap_or_else(|error| error.into_inner());
         if !self.accepting.load(Ordering::Acquire) {
             return false;
         }
         let handle = tokio::spawn(task(self.cancellation.child_token()));
-        if let Some(previous) = self.tasks.lock().unwrap_or_else(|error| error.into_inner()).insert(key.into(), handle)
-        {
+        if let Some(previous) = tasks.insert(key, handle) {
             previous.abort();
         }
         true
     }
 
+    pub fn spawn_once<F, Fut>(&self, key: impl Into<String>, task: F) -> bool
+    where
+        F: FnOnce(CancellationToken) -> Fut + Send + 'static,
+        Fut: Future<Output = ()> + Send + 'static,
+    {
+        // One-shot cleanup tasks are keyed so duplicate requests do not accumulate, and
+        // completed handles remove themselves from the supervisor.
+        let key = key.into();
+        let mut tasks = self.tasks.lock().unwrap_or_else(|error| error.into_inner());
+        if !self.accepting.load(Ordering::Acquire) || tasks.contains_key(&key) {
+            return false;
+        }
+        let cleanup = self.clone();
+        let task_key = key.clone();
+        // Do not let a very short task finish before its handle is registered in the map.
+        let (start, started) = tokio::sync::oneshot::channel();
+        let handle = tokio::spawn(async move {
+            if started.await.is_err() {
+                return;
+            }
+            task(cleanup.cancellation.child_token()).await;
+            cleanup.remove_completed(&task_key);
+        });
+        tasks.insert(key, handle);
+        drop(tasks);
+        let _ = start.send(());
+        true
+    }
+
     pub fn stop(&self, key: &str) {
         if let Some(task) = self.tasks.lock().unwrap_or_else(|error| error.into_inner()).remove(key) {
             task.abort();
@@ -62,6 +92,10 @@ impl TaskSupervisor {
         self.tasks.lock().unwrap_or_else(|error| error.into_inner()).len()
     }
 
+    fn remove_completed(&self, key: &str) {
+        self.tasks.lock().unwrap_or_else(|error| error.into_inner()).remove(key);
+    }
+
     pub async fn shutdown(&self, deadline: Duration) {
         self.accepting.store(false, Ordering::Release);
         self.cancellation.cancel();
@@ -116,4 +150,23 @@ mod tests {
         assert_eq!(supervisor.active_count(), 0);
         assert!(!supervisor.spawn_replace("late", |_| async {}));
     }
+
+    #[tokio::test]
+    async fn spawn_once_removes_completed_task() {
+        let supervisor = TaskSupervisor::new();
+        assert!(supervisor.spawn_once("one-shot", |_| async {}));
+        tokio::time::sleep(Duration::from_millis(1)).await;
+        assert_eq!(supervisor.active_count(), 0);
+    }
+
+    #[tokio::test]
+    async fn spawn_once_rejects_duplicate_active_key() {
+        let supervisor = TaskSupervisor::new();
+        assert!(supervisor.spawn_once("one-shot", |token| async move {
+            token.cancelled().await;
+        }));
+        assert!(!supervisor.spawn_once("one-shot", |_| async {}));
+        assert_eq!(supervisor.active_count(), 1);
+        supervisor.shutdown(Duration::from_secs(1)).await;
+    }
 }
diff --git a/crates/dbx-core/src/transfer.rs b/crates/dbx-core/src/transfer.rs
index 1c9059e48f..a39e604feb 100644
--- a/crates/dbx-core/src/transfer.rs
+++ b/crates/dbx-core/src/transfer.rs
@@ -2082,6 +2082,63 @@ fn generate_transfer_write_sql(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
+pub(crate) fn generate_insert_typed_sql_batches(
+    columns: &[String],
+    column_types: &[Option<String>],
+    rows: &[Vec<serde_json::Value>],
+    table: &str,
+    schema: &str,
+    db_type: &DatabaseType,
+    requested_max_rows: usize,
+) -> Vec<(String, usize)> {
+    if rows.is_empty() {
+        return Vec::new();
+    }
+
+    let max_rows = requested_max_rows.max(1);
+    let max_sql_bytes = match db_type {
+        DatabaseType::CloudflareD1 => crate::db::cloudflare_d1::MAX_SQL_STATEMENT_BYTES,
+        _ => MAX_TRANSFER_WRITE_SQL_BYTES,
+    };
+    let mut statements = Vec::new();
+    let mut start = 0;
+
+    // First honor the row limit, then use binary search to find the largest statement that
+    // also fits the backend byte limit. This avoids generating every intermediate size.
+    while start < rows.len() {
+        let max_end = start.saturating_add(max_rows).min(rows.len());
+        let mut end = max_end;
+        let mut accepted = generate_insert_typed(columns, column_types, &rows[start..max_end], table, schema, db_type);
+
+        if accepted.len() > max_sql_bytes && max_end > start + 1 {
+            end = start + 1;
+            accepted = generate_insert_typed(columns, column_types, &rows[start..end], table, schema, db_type);
+            let mut low = start + 2;
+            let mut high = max_end;
+            while low <= high {
+                let candidate_end = low + (high - low) / 2;
+                let candidate =
+                    generate_insert_typed(columns, column_types, &rows[start..candidate_end], table, schema, db_type);
+                if candidate.len() <= max_sql_bytes {
+                    accepted = candidate;
+                    end = candidate_end;
+                    low = candidate_end + 1;
+                } else {
+                    high = candidate_end - 1;
+                }
+            }
+        }
+
+        if !accepted.is_empty() {
+            statements.push((accepted, end - start));
+        }
+        start = end;
+    }
+
+    statements
+}
+
 #[allow(clippy::too_many_arguments)]
 fn generate_transfer_write_sql_batches(
     mode: &TransferMode,
@@ -2097,6 +2154,21 @@ fn generate_transfer_write_sql_batches(
         return Vec::new();
     }
 
+    if matches!(mode, TransferMode::Append | TransferMode::Overwrite) {
+        return generate_insert_typed_sql_batches(
+            columns,
+            column_types,
+            rows,
+            table,
+            schema,
+            db_type,
+            max_transfer_write_rows(db_type, mode),
+        )
+        .into_iter()
+        .map(|(sql, _)| sql)
+        .collect();
+    }
+
     let max_rows = max_transfer_write_rows(db_type, mode);
     let max_sql_bytes = match db_type {
         DatabaseType::CloudflareD1 => crate::db::cloudflare_d1::MAX_SQL_STATEMENT_BYTES,
diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rs
index 1a928f10ba..c2b7bcb599 100644
--- a/crates/dbx-web/src/main.rs
+++ b/crates/dbx-web/src/main.rs
@@ -181,6 +181,7 @@ async fn main() {
         password_hash: RwLock::new(password_hash),
         sessions: RwLock::new(HashSet::new()),
         sse_channels: RwLock::new(HashMap::new()),
+        table_import_channels: RwLock::new(HashMap::new()),
         sql_file_executions: RwLock::new(HashMap::new()),
         login_rate_limit: tokio::sync::Mutex::new(state::LoginRateLimit { fail_count: 0, locked_until: None }),
         export_files: RwLock::new(HashMap::new()),
@@ -561,6 +562,8 @@ async fn main() {
         .route("/sql-file/cancel", post(routes::sql_file::cancel_sql_file))
         // Table import
         .route("/import/preview", post(routes::table_import::preview_import))
+        .route("/import/preview-source", post(routes::table_import::preview_uploaded_import))
+        .route("/import/source/release", post(routes::table_import::release_import_source))
         .route("/import/execute", post(routes::table_import::execute_import))
         .route("/import/progress/{importId}", get(routes::table_import::import_progress))
         .route("/import/cancel", post(routes::table_import::cancel_import))
diff --git a/crates/dbx-web/src/routes/connection.rs b/crates/dbx-web/src/routes/connection.rs
index 58b2bf5420..8bfa719195 100644
--- a/crates/dbx-web/src/routes/connection.rs
+++ b/crates/dbx-web/src/routes/connection.rs
@@ -493,6 +493,7 @@ mod tests {
             password_hash: RwLock::new(None),
             sessions: RwLock::new(HashSet::new()),
             sse_channels: RwLock::new(HashMap::new()),
+            table_import_channels: RwLock::new(HashMap::new()),
             sql_file_executions: RwLock::new(HashMap::new()),
             login_rate_limit: Mutex::new(LoginRateLimit { fail_count: 0, locked_until: None }),
             export_files: RwLock::new(HashMap::new()),
diff --git a/crates/dbx-web/src/routes/mongo.rs b/crates/dbx-web/src/routes/mongo.rs
index a7323bb1f9..2fe83cca14 100644
--- a/crates/dbx-web/src/routes/mongo.rs
+++ b/crates/dbx-web/src/routes/mongo.rs
@@ -834,6 +834,7 @@ mod tests {
             password_hash: RwLock::new(None),
             sessions: RwLock::new(HashSet::new()),
             sse_channels: RwLock::new(HashMap::new()),
+            table_import_channels: RwLock::new(HashMap::new()),
             sql_file_executions: RwLock::new(HashMap::new()),
             login_rate_limit: Mutex::new(LoginRateLimit { fail_count: 0, locked_until: None }),
             export_files: RwLock::new(HashMap::new()),
diff --git a/crates/dbx-web/src/routes/table_import.rs b/crates/dbx-web/src/routes/table_import.rs
index cabe026f2c..867cee1195 100644
--- a/crates/dbx-web/src/routes/table_import.rs
+++ b/crates/dbx-web/src/routes/table_import.rs
@@ -1,13 +1,14 @@
 use std::path::{Path as StdPath, PathBuf};
 use std::sync::Arc;
-use std::time::{Duration, SystemTime};
+use std::time::{Duration, Instant, SystemTime};
 
 use axum::body::Bytes;
 use axum::extract::{Multipart, Path, State};
 use axum::response::sse::{Event, Sse};
 use axum::Json;
 use dbx_core::table_import::{
-    self, TableImportParseOptions, TableImportPreviewRequest, TableImportRequest, TableImportSourceFormat,
+    self, TableImportParseOptions, TableImportPhase, TableImportPreviewRequest, TableImportProgress,
+    TableImportRequest, TableImportSourceFormat, TableImportStatus,
 };
 use dbx_core::transfer;
 use futures::stream::Stream;
@@ -19,6 +20,52 @@ use crate::error::AppError;
 use crate::state::WebState;
 
 const MAX_IMPORT_UPLOAD_BYTES: usize = 100 * 1024 * 1024;
+const TABLE_IMPORT_PROGRESS_TTL: Duration = Duration::from_secs(30);
+
+fn initial_import_progress(import_id: &str, started_at: Instant) -> TableImportProgress {
+    TableImportProgress {
+        import_id: import_id.to_string(),
+        status: TableImportStatus::Running,
+        phase: TableImportPhase::Preparing,
+        rows_imported: 0,
+        total_rows: 0,
+        total_rows_exact: false,
+        bytes_read: 0,
+        total_bytes: 0,
+        elapsed_ms: started_at.elapsed().as_millis(),
+        error: None,
+    }
+}
+
+fn failed_import_progress(import_id: &str, started_at: Instant, error: String) -> TableImportProgress {
+    TableImportProgress {
+        import_id: import_id.to_string(),
+        status: TableImportStatus::Error,
+        phase: TableImportPhase::Done,
+        rows_imported: 0,
+        total_rows: 0,
+        total_rows_exact: true,
+        bytes_read: 0,
+        total_bytes: 0,
+        elapsed_ms: started_at.elapsed().as_millis(),
+        error: Some(error),
+    }
+}
+
+fn send_import_progress(tx: &tokio::sync::watch::Sender<String>, progress: &TableImportProgress) {
+    if let Ok(json) = serde_json::to_string(progress) {
+        tx.send_replace(json);
+    }
+}
+
+fn schedule_import_progress_cleanup(state: Arc<WebState>, import_id: String) {
+    // Keep the terminal snapshot briefly so an SSE client that connects after completion can
+    // still observe the result, then release the channel and its captured state.
+    tokio::spawn(async move {
+        tokio::time::sleep(TABLE_IMPORT_PROGRESS_TTL).await;
+        state.table_import_channels.write().await.remove(&import_id);
+    });
+}
 
 #[derive(Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -32,6 +79,24 @@ pub struct CancelImportRequest {
     pub import_id: String,
 }
 
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PreviewUploadedImportRequest {
+    pub source_ref: String,
+    #[serde(default)]
+    pub source_format: Option<TableImportSourceFormat>,
+    #[serde(default)]
+    pub parse_options: TableImportParseOptions,
+    #[serde(default)]
+    pub preview_limit: Option<usize>,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReleaseImportSourceRequest {
+    pub source_ref: String,
+}
+
 pub async fn preview_import(
     State(state): State<Arc<WebState>>,
     mut multipart: Multipart,
@@ -133,6 +198,34 @@ pub async fn preview_import(
     Err(AppError::from("No file uploaded".to_string()))
 }
 
+pub async fn preview_uploaded_import(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<PreviewUploadedImportRequest>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let file_path = uploaded_import_path_for_source_ref(&state.data_dir, &request.source_ref)?;
+    let preview = table_import::preview_table_import_file_with_request(TableImportPreviewRequest {
+        file_path: file_path.to_string_lossy().to_string(),
+        source_ref: Some(request.source_ref),
+        source_format: request.source_format,
+        parse_options: request.parse_options,
+        preview_limit: request.preview_limit,
+    })
+    .await
+    .map_err(AppError::from)?;
+    serde_json::to_value(preview).map(Json).map_err(|error| AppError::from(error.to_string()))
+}
+
+pub async fn release_import_source(
+    State(state): State<Arc<WebState>>,
+    Json(request): Json<ReleaseImportSourceRequest>,
+) -> Json<serde_json::Value> {
+    let released = match uploaded_import_path_for_source_ref(&state.data_dir, &request.source_ref) {
+        Ok(file_path) => tokio::fs::remove_file(file_path).await.is_ok(),
+        Err(_) => false,
+    };
+    Json(serde_json::json!({ "released": released }))
+}
+
 async fn write_import_upload(field: axum::extract::multipart::Field<'_>, file_path: &StdPath) -> Result<(), AppError> {
     write_import_upload_stream(field, file_path, MAX_IMPORT_UPLOAD_BYTES).await
 }
@@ -176,13 +269,16 @@ pub async fn execute_import(
     State(state): State<Arc<WebState>>,
     Json(body): Json<ExecuteImportWrapper>,
 ) -> Result<Json<serde_json::Value>, AppError> {
+    let started_at = Instant::now();
     let mut req = body.request;
     let file_path = validated_uploaded_import_path(&state.data_dir, &req.file_path)?;
     req.file_path = file_path.to_string_lossy().to_string();
 
     // Reject import early if the connection is read-only
     if let Some(name) = dbx_core::query::connection_readonly_name(&state.app, &req.connection_id).await {
-        cleanup_uploaded_import_source(&req.file_path).await;
+        if !req.retain_source {
+            cleanup_uploaded_import_source(&req.file_path).await;
+        }
         return Err(AppError::from(format!(
             "Read-only mode: connection '{}' has read-only protection enabled. Import blocked.",
             name
@@ -191,8 +287,12 @@ pub async fn execute_import(
 
     let import_id = req.import_id.clone();
 
-    let (tx, _) = tokio::sync::broadcast::channel::<String>(256);
-    state.sse_channels.write().await.insert(import_id.clone(), tx.clone());
+    let initial_progress = serde_json::to_string(&initial_import_progress(&import_id, started_at))
+        .map_err(|error| AppError::from(error.to_string()))?;
+    // Unlike broadcast, watch retains the latest progress and cannot drop the terminal update
+    // when the browser subscribes slightly after the import starts.
+    let (tx, _) = tokio::sync::watch::channel(initial_progress);
+    state.table_import_channels.write().await.insert(import_id.clone(), tx.clone());
 
     let app = state.app.clone();
     let state_clone = state.clone();
@@ -201,18 +301,11 @@ pub async fn execute_import(
         let db_type = match transfer::get_db_type(&app, &req.connection_id).await {
             Ok(t) => t,
             Err(e) => {
-                let _ = tx.send(
-                    serde_json::json!({
-                        "importId": req.import_id.clone(),
-                        "status": "error",
-                        "rowsImported": 0,
-                        "totalRows": 0,
-                        "error": e
-                    })
-                    .to_string(),
-                );
-                cleanup_uploaded_import_source(&req.file_path).await;
-                state_clone.sse_channels.write().await.remove(&req.import_id);
+                send_import_progress(&tx, &failed_import_progress(&req.import_id, started_at, e));
+                if !req.retain_source {
+                    cleanup_uploaded_import_source(&req.file_path).await;
+                }
+                schedule_import_progress_cleanup(state_clone, req.import_id.clone());
                 return;
             }
         };
@@ -220,24 +313,16 @@ pub async fn execute_import(
         let pool_key = match app.get_or_create_pool(&req.connection_id, Some(&req.database)).await {
             Ok(k) => k,
             Err(e) => {
-                let _ = tx.send(
-                    serde_json::json!({
-                        "importId": req.import_id.clone(),
-                        "status": "error",
-                        "rowsImported": 0,
-                        "totalRows": 0,
-                        "error": e
-                    })
-                    .to_string(),
-                );
-                cleanup_uploaded_import_source(&req.file_path).await;
-                state_clone.sse_channels.write().await.remove(&req.import_id);
+                send_import_progress(&tx, &failed_import_progress(&req.import_id, started_at, e));
+                if !req.retain_source {
+                    cleanup_uploaded_import_source(&req.file_path).await;
+                }
+                schedule_import_progress_cleanup(state_clone, req.import_id.clone());
                 return;
             }
         };
 
         let tx_clone = tx.clone();
-        let import_id_for_cancel = req.import_id.clone();
         let result = table_import::import_table_file_core(
             &app,
             &req,
@@ -247,36 +332,16 @@ pub async fn execute_import(
                 let id = id.to_string();
                 Box::pin(async move { transfer::is_cancelled(&id).await })
             },
-            |progress| {
-                if let Ok(json) = serde_json::to_string(&progress) {
-                    let _ = tx_clone.send(json);
-                }
-            },
+            |progress| send_import_progress(&tx_clone, &progress),
         )
         .await;
 
-        match result {
-            Ok(summary) => {
-                if let Ok(json) = serde_json::to_string(&summary) {
-                    let _ = tx.send(json);
-                }
-            }
-            Err(e) => {
-                let _ = tx.send(
-                    serde_json::json!({
-                        "importId": import_id_for_cancel,
-                        "status": "error",
-                        "rowsImported": 0,
-                        "totalRows": 0,
-                        "error": e
-                    })
-                    .to_string(),
-                );
-            }
-        }
+        let _ = result;
 
-        cleanup_uploaded_import_source(&req.file_path).await;
-        state_clone.sse_channels.write().await.remove(&req.import_id);
+        if !req.retain_source {
+            cleanup_uploaded_import_source(&req.file_path).await;
+        }
+        schedule_import_progress_cleanup(state_clone, req.import_id.clone());
     });
 
     Ok(Json(serde_json::json!({ "importId": import_id })))
@@ -286,11 +351,11 @@ pub async fn import_progress(
     State(state): State<Arc<WebState>>,
     Path(import_id): Path<String>,
 ) -> Result<Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>>, AppError> {
-    let channels = state.sse_channels.read().await;
+    let channels = state.table_import_channels.read().await;
     let tx = channels.get(&import_id).ok_or_else(|| AppError::from("Import not found".to_string()))?;
     let rx = tx.subscribe();
     drop(channels);
-    Ok(crate::sse::sse_from_channel(rx))
+    Ok(crate::sse::sse_from_watch(rx))
 }
 
 pub async fn cancel_import(
@@ -328,6 +393,22 @@ fn validated_uploaded_import_path(data_dir: &StdPath, file_path: &str) -> Result
     Ok(canonical_path)
 }
 
+fn uploaded_import_path_for_source_ref(data_dir: &StdPath, source_ref: &str) -> Result<PathBuf, AppError> {
+    uuid::Uuid::parse_str(source_ref).map_err(|_| AppError::from("Invalid import source reference".to_string()))?;
+    let tmp_dir = import_upload_dir(data_dir);
+    let prefix = format!("{source_ref}-");
+    let mut matches = std::fs::read_dir(&tmp_dir)
+        .map_err(|_| AppError::from("Import source is no longer available".to_string()))?
+        .filter_map(Result::ok)
+        .filter(|entry| entry.file_name().to_string_lossy().starts_with(&prefix))
+        .map(|entry| entry.path());
+    let file_path = matches.next().ok_or_else(|| AppError::from("Import source is no longer available".to_string()))?;
+    if matches.next().is_some() {
+        return Err(AppError::from("Import source reference is ambiguous".to_string()));
+    }
+    validated_uploaded_import_path(data_dir, &file_path.to_string_lossy())
+}
+
 fn cleanup_expired_import_uploads(tmp_dir: &StdPath, max_age: Duration) {
     let Ok(entries) = std::fs::read_dir(tmp_dir) else {
         return;
@@ -401,4 +482,47 @@ mod tests {
         assert_eq!(error.message, "multipart stream failed");
         assert!(!file_path.exists());
     }
+
+    #[test]
+    fn resolves_uploaded_import_source_by_uuid_reference() {
+        let data_dir = std::env::temp_dir().join(format!("dbx-table-import-data-{}", uuid::Uuid::new_v4()));
+        let upload_dir = import_upload_dir(&data_dir);
+        std::fs::create_dir_all(&upload_dir).unwrap();
+        let source_ref = uuid::Uuid::new_v4().to_string();
+        let file_path = upload_dir.join(format!("{source_ref}-users.csv"));
+        std::fs::write(&file_path, b"id,name\n1,Ada\n").unwrap();
+
+        let resolved = uploaded_import_path_for_source_ref(&data_dir, &source_ref)
+            .unwrap_or_else(|error| panic!("failed to resolve uploaded source: {}", error.message));
+
+        assert_eq!(resolved, file_path.canonicalize().unwrap());
+        assert!(uploaded_import_path_for_source_ref(&data_dir, "../users.csv").is_err());
+        assert!(uploaded_import_path_for_source_ref(&data_dir, &uuid::Uuid::new_v4().to_string()).is_err());
+        let _ = std::fs::remove_dir_all(data_dir);
+    }
+
+    #[test]
+    fn import_progress_watch_replays_terminal_state_to_late_subscribers() {
+        let started_at = Instant::now();
+        let initial = serde_json::to_string(&initial_import_progress("import-1", started_at)).unwrap();
+        let (tx, _) = tokio::sync::watch::channel(initial);
+        let terminal = TableImportProgress {
+            import_id: "import-1".to_string(),
+            status: TableImportStatus::Done,
+            phase: TableImportPhase::Done,
+            rows_imported: 2,
+            total_rows: 2,
+            total_rows_exact: true,
+            bytes_read: 20,
+            total_bytes: 20,
+            elapsed_ms: 10,
+            error: None,
+        };
+        send_import_progress(&tx, &terminal);
+
+        let late_subscriber = tx.subscribe();
+        let replayed: serde_json::Value = serde_json::from_str(&late_subscriber.borrow()).unwrap();
+        assert_eq!(replayed["status"], "done");
+        assert_eq!(replayed["rowsImported"], 2);
+    }
 }
diff --git a/crates/dbx-web/src/sse.rs b/crates/dbx-web/src/sse.rs
index fa7ed3550b..c41c659c66 100644
--- a/crates/dbx-web/src/sse.rs
+++ b/crates/dbx-web/src/sse.rs
@@ -1,6 +1,7 @@
 use axum::response::sse::{Event, KeepAlive, Sse};
 use futures::stream::Stream;
 use tokio::sync::broadcast::{self, error::RecvError};
+use tokio::sync::watch;
 
 pub fn sse_from_channel(
     rx: broadcast::Receiver<String>,
@@ -32,3 +33,21 @@ fn sse_from_channel_with_lag_policy(
     };
     Sse::new(stream).keep_alive(KeepAlive::default())
 }
+
+pub fn sse_from_watch(
+    mut rx: watch::Receiver<String>,
+) -> Sse<impl Stream<Item = Result<Event, std::convert::Infallible>>> {
+    // A watch channel stores the latest state, so late subscribers immediately receive the
+    // current progress, including a terminal result, instead of waiting for a new event.
+    let stream = async_stream::stream! {
+        let initial = rx.borrow().clone();
+        if !initial.is_empty() {
+            yield Ok(Event::default().data(initial));
+        }
+        while rx.changed().await.is_ok() {
+            let update = rx.borrow().clone();
+            yield Ok(Event::default().data(update));
+        }
+    };
+    Sse::new(stream).keep_alive(KeepAlive::default())
+}
diff --git a/crates/dbx-web/src/state.rs b/crates/dbx-web/src/state.rs
index 19b4ffa70c..f92a021adb 100644
--- a/crates/dbx-web/src/state.rs
+++ b/crates/dbx-web/src/state.rs
@@ -2,7 +2,7 @@ use dbx_core::connection::AppState;
 use std::collections::{HashMap, HashSet};
 use std::path::PathBuf;
 use std::sync::Arc;
-use tokio::sync::{broadcast, Mutex, RwLock};
+use tokio::sync::{broadcast, watch, Mutex, RwLock};
 use tokio_util::sync::CancellationToken;
 
 pub struct LoginRateLimit {
@@ -18,6 +18,7 @@ pub struct WebState {
     pub password_hash: RwLock<Option<String>>,
     pub sessions: RwLock<HashSet<String>>,
     pub sse_channels: RwLock<HashMap<String, broadcast::Sender<String>>>,
+    pub table_import_channels: RwLock<HashMap<String, watch::Sender<String>>>,
     pub sql_file_executions: RwLock<HashMap<String, CancellationToken>>,
     pub login_rate_limit: Mutex<LoginRateLimit>,
     /// Table export temp files: export_id -> (file_path, format)
diff --git a/package.json b/package.json
index 27f5f8a774..d8d55872bb 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,7 @@
     "test:db-env": "node --test scripts/database-env.test.mjs",
     "bench:redis-key-search": "node scripts/bench/redis-key-search.mjs",
     "bench:mongodb-count": "node scripts/bench/mongodb-count.mjs",
+    "bench:table-import": "cargo run -p dbx-core --no-default-features --example table_import_bench --release --",
     "lint": "oxlint --vue-plugin apps/desktop/src",
     "fmt": "oxfmt \"apps/desktop/src/**/*.{ts,vue}\"",
     "test": "vitest run",
diff --git a/src-tauri/src/commands/table_import.rs b/src-tauri/src/commands/table_import.rs
index 9e282007c3..e21ada8cf9 100644
--- a/src-tauri/src/commands/table_import.rs
+++ b/src-tauri/src/commands/table_import.rs
@@ -1,5 +1,6 @@
 use std::collections::HashSet;
 use std::sync::{Arc, OnceLock};
+use std::time::Instant;
 
 use tauri::{AppHandle, Emitter, State};
 use tokio::sync::RwLock;
@@ -22,6 +23,25 @@ fn emit_progress(app: &AppHandle, progress: TableImportProgress) {
     let _ = app.emit("table-import-progress", progress);
 }
 
+fn split_command_progress(
+    mut progress: TableImportProgress,
+) -> (Option<TableImportProgress>, Option<TableImportProgress>) {
+    // Core import completion precedes session-pool cleanup. Publish a synthetic finalizing
+    // state first so the UI cannot show 100% until command-level cleanup has finished.
+    match progress.status {
+        dbx_core::table_import::TableImportStatus::Running => (Some(progress), None),
+        dbx_core::table_import::TableImportStatus::Done => {
+            let terminal = progress.clone();
+            progress.status = dbx_core::table_import::TableImportStatus::Running;
+            progress.phase = dbx_core::table_import::TableImportPhase::Finalizing;
+            (Some(progress), Some(terminal))
+        }
+        dbx_core::table_import::TableImportStatus::Error | dbx_core::table_import::TableImportStatus::Cancelled => {
+            (None, Some(progress))
+        }
+    }
+}
+
 async fn is_cancelled(import_id: &str) -> bool {
     cancelled_imports().read().await.contains(import_id)
 }
@@ -41,6 +61,7 @@ pub async fn import_table_file(
     state: State<'_, Arc<AppState>>,
     request: TableImportRequest,
 ) -> Result<TableImportSummary, String> {
+    let command_started_at = Instant::now();
     clear_cancelled(&request.import_id).await;
     // Reject import early if the connection is read-only — importing is inherently a write operation
     ensure_connection_writable(&state, &request.connection_id, "Import").await?;
@@ -50,18 +71,53 @@ pub async fn import_table_file(
     let pool_key =
         state.get_or_create_pool_for_session(&request.connection_id, database, Some(&client_session_id)).await?;
 
-    let result = dbx_core::table_import::import_table_file_core(
+    let core_started_at = Instant::now();
+    let mut deferred_terminal = None;
+    let mut result = dbx_core::table_import::import_table_file_core(
         &state,
         &request,
         &db_type,
         &pool_key,
         |import_id| Box::pin(is_cancelled(import_id)),
-        |progress| emit_progress(&app, progress),
+        |progress| {
+            let (immediate, terminal) = split_command_progress(progress);
+            if let Some(progress) = immediate {
+                emit_progress(&app, progress);
+            }
+            if terminal.is_some() {
+                deferred_terminal = terminal;
+            }
+        },
     )
     .await;
+    let core_ms = core_started_at.elapsed().as_millis();
 
-    let _ = state.close_client_session_pool(&request.connection_id, database, &client_session_id).await;
+    let cleanup_started_at = Instant::now();
+    let detached = state.detach_client_session_pool(&request.connection_id, database, &client_session_id).await;
+    let cleanup_detach_ms = cleanup_started_at.elapsed().as_millis();
+    log::info!(
+        "[table-import:cleanup] import_id={} cleanup_detach_ms={} pool_detached={}",
+        request.import_id,
+        cleanup_detach_ms,
+        detached.unwrap_or(false)
+    );
+
+    let command_ms = command_started_at.elapsed().as_millis();
+    if let Some(mut terminal) = deferred_terminal {
+        terminal.elapsed_ms = terminal.elapsed_ms.max(command_ms);
+        emit_progress(&app, terminal);
+    }
+    if let Ok(summary) = &mut result {
+        summary.elapsed_ms = summary.elapsed_ms.max(command_ms);
+    }
     clear_cancelled(&request.import_id).await;
+    log::info!(
+        "[table-import:command] import_id={} core_ms={} command_ms={} cleanup_detach_ms={} cleanup_scheduled=true",
+        request.import_id,
+        core_ms,
+        command_ms,
+        cleanup_detach_ms
+    );
     result
 }
 
@@ -70,3 +126,43 @@ pub async fn cancel_table_import(import_id: String) -> Result<bool, String> {
     cancelled_imports().write().await.insert(import_id);
     Ok(true)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use dbx_core::table_import::{TableImportPhase, TableImportStatus};
+
+    fn progress(status: TableImportStatus) -> TableImportProgress {
+        TableImportProgress {
+            import_id: "import-1".to_string(),
+            status,
+            phase: TableImportPhase::Done,
+            rows_imported: 10,
+            total_rows: 10,
+            total_rows_exact: true,
+            bytes_read: 100,
+            total_bytes: 100,
+            elapsed_ms: 25,
+            error: None,
+        }
+    }
+
+    #[test]
+    fn successful_core_terminal_is_finalizing_until_command_cleanup_finishes() {
+        let (immediate, terminal) = split_command_progress(progress(TableImportStatus::Done));
+
+        let immediate = immediate.expect("finalizing progress");
+        assert_eq!(immediate.status, TableImportStatus::Running);
+        assert_eq!(immediate.phase, TableImportPhase::Finalizing);
+        assert_eq!(terminal.expect("deferred terminal").status, TableImportStatus::Done);
+    }
+
+    #[test]
+    fn error_and_cancelled_terminals_are_deferred_without_fake_running_events() {
+        for status in [TableImportStatus::Error, TableImportStatus::Cancelled] {
+            let (immediate, terminal) = split_command_progress(progress(status));
+            assert!(immediate.is_none());
+            assert_eq!(terminal.expect("deferred terminal").status, status);
+        }
+    }
+}