diff --git a/apps/desktop/src/components/import/TableImportDialog.vue b/apps/desktop/src/components/import/TableImportDialog.vue
index 1415bd6d87..af479475f9 100644
--- a/apps/desktop/src/components/import/TableImportDialog.vue
+++ b/apps/desktop/src/components/import/TableImportDialog.vue
@@ -72,7 +72,9 @@ const errorMessage = ref("");
 const wizardStep = ref<TableImportWizardStep>("source");
 const fileInput = ref<HTMLInputElement | null>(null);
 const delimiter = ref(",");
-const hasHeader = ref(true);
+const titleRow = ref(1);
+const dataStartRow = ref(2);
+const lastDataRow = ref(0);
 const trimValues = ref(false);
 const emptyStringAsNull = ref(true);
 const selectedSheet = ref("");
@@ -167,7 +169,9 @@ const createColumnSummaries = computed(() =>
 );
 const parseOptions = computed<api.TableImportParseOptions>(() => ({
   delimiter: sourceFormat.value === "tsv" ? "\\t" : sourceFormat.value === "csv" ? "," : delimiter.value,
-  hasHeader: hasHeader.value,
+  titleRow: titleRow.value,
+  dataStartRow: dataStartRow.value,
+  lastDataRow: lastDataRow.value,
   trimValues: trimValues.value,
   emptyStringAsNull: emptyStringAsNull.value,
   sheetName: sourceFormat.value === "excel" ? selectedSheet.value || null : null,
@@ -184,7 +188,9 @@ function resetState() {
   activeTaskIndex.value = 0;
   sourceFormat.value = "csv";
   delimiter.value = ",";
-  hasHeader.value = true;
+  titleRow.value = 1;
+  dataStartRow.value = 2;
+  lastDataRow.value = 0;
   trimValues.value = false;
   emptyStringAsNull.value = true;
   selectedSheet.value = "";
@@ -234,7 +240,9 @@ function uniqueTableName(baseName: string, usedNames: Set<string>): string {
 function taskParseOptions(format: api.TableImportSourceFormat, sheetName = ""): api.TableImportParseOptions {
   return {
     delimiter: format === "tsv" ? "\\t" : format === "csv" ? "," : delimiter.value,
-    hasHeader: hasHeader.value,
+    titleRow: titleRow.value,
+    dataStartRow: dataStartRow.value,
+    lastDataRow: lastDataRow.value,
     trimValues: trimValues.value,
     emptyStringAsNull: emptyStringAsNull.value,
     sheetName: format === "excel" ? sheetName || null : null,
@@ -716,7 +724,7 @@ watch(
   { immediate: true },
 );
 
-watch([sourceFormat, delimiter, hasHeader, trimValues, emptyStringAsNull, selectedSheet, jsonShape, previewLimit], schedulePreviewReload);
+watch([sourceFormat, delimiter, titleRow, dataStartRow, lastDataRow, trimValues, emptyStringAsNull, selectedSheet, jsonShape, previewLimit], schedulePreviewReload);
 watch([newTableName, columnMapping, columnDataTypes], saveActiveBatchTask, { deep: true });
 watch(targetMode, (mode) => {
   if (mode === "existing") {
@@ -883,10 +891,18 @@ watch(targetMode, (mode) => {
               <Label class="text-xs">{{ t("tableImport.delimiter") }}</Label>
               <Input v-model="delimiter" :disabled="sourceFormat !== 'delimited'" class="h-8 text-xs font-mono" />
             </div>
-            <label class="flex items-center gap-2 text-xs">
-              <input v-model="hasHeader" type="checkbox" class="h-3.5 w-3.5 accent-primary" />
-              {{ t("tableImport.hasHeader") }}
-            </label>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.titleRow") }}</Label>
+              <Input v-model.number="titleRow" type="number" min="0" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.dataStartRow") }}</Label>
+              <Input v-model.number="dataStartRow" type="number" min="1" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.lastDataRow") }}</Label>
+              <Input v-model.number="lastDataRow" type="number" min="0" class="h-8 text-xs" />
+            </div>
             <label class="flex items-center gap-2 text-xs">
               <input v-model="trimValues" type="checkbox" class="h-3.5 w-3.5 accent-primary" />
               {{ t("tableImport.trimValues") }}
@@ -913,7 +929,7 @@ watch(targetMode, (mode) => {
             </div>
           </div>
 
-          <div v-else-if="sourceFormat === 'excel'" class="grid grid-cols-3 gap-3 rounded-md border p-3">
+          <div v-else-if="sourceFormat === 'excel'" class="grid grid-cols-4 gap-3 rounded-md border p-3">
             <div class="space-y-1.5">
               <Label class="text-xs">{{ t("tableImport.sheet") }}</Label>
               <Select :model-value="selectedSheet" :disabled="!preview?.sheets?.length" @update:model-value="(value: any) => (selectedSheet = value)">
@@ -925,10 +941,18 @@ watch(targetMode, (mode) => {
                 </SelectContent>
               </Select>
             </div>
-            <label class="flex items-center gap-2 text-xs">
-              <input v-model="hasHeader" type="checkbox" class="h-3.5 w-3.5 accent-primary" />
-              {{ t("tableImport.hasHeader") }}
-            </label>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.titleRow") }}</Label>
+              <Input v-model.number="titleRow" type="number" min="0" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.dataStartRow") }}</Label>
+              <Input v-model.number="dataStartRow" type="number" min="1" class="h-8 text-xs" />
+            </div>
+            <div class="space-y-1.5">
+              <Label class="text-xs">{{ t("tableImport.lastDataRow") }}</Label>
+              <Input v-model.number="lastDataRow" type="number" min="0" class="h-8 text-xs" />
+            </div>
           </div>
 
           <div class="flex items-center gap-2">
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index 5360d5d022..64f8fd9725 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -2554,6 +2554,9 @@ export default {
     previewRows: "Preview rows",
     delimiter: "Delimiter",
     hasHeader: "First row is header",
+    titleRow: "Title row (0 for none)",
+    dataStartRow: "Data start row",
+    lastDataRow: "Last data row (0 for end)",
     trimValues: "Trim values",
     emptyStringAsNull: "Empty string as NULL",
     jsonShape: "JSON rows",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index fc56378e8a..e46d31a8c6 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -2553,6 +2553,9 @@ export default withEnglishFallback({
     previewRows: "预览行数",
     delimiter: "分隔符",
     hasHeader: "首行为表头",
+    titleRow: "标题行（0 表示无）",
+    dataStartRow: "数据开始行",
+    lastDataRow: "最后数据行（0 表示末尾）",
     trimValues: "裁剪空白",
     emptyStringAsNull: "空字符串作为 NULL",
     jsonShape: "JSON 行结构",
diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.ts
index bc11bc31cb..ffefecb74d 100644
--- a/apps/desktop/src/lib/backend/tauri.ts
+++ b/apps/desktop/src/lib/backend/tauri.ts
@@ -2094,6 +2094,9 @@ export interface TableImportColumnMapping {
 export interface TableImportParseOptions {
   delimiter?: string | null;
   hasHeader?: boolean | null;
+  titleRow?: number | null;
+  dataStartRow?: number | null;
+  lastDataRow?: number | null;
   trimValues?: boolean | null;
   emptyStringAsNull?: boolean | null;
   sheetName?: string | null;
diff --git a/crates/dbx-core/src/table_import.rs b/crates/dbx-core/src/table_import.rs
index 173e7700c2..3619e6fa4a 100644
--- a/crates/dbx-core/src/table_import.rs
+++ b/crates/dbx-core/src/table_import.rs
@@ -101,6 +101,9 @@ pub enum TableImportJsonShape {
 pub struct TableImportParseOptions {
     pub delimiter: Option<String>,
     pub has_header: Option<bool>,
+    pub title_row: Option<usize>,
+    pub data_start_row: Option<usize>,
+    pub last_data_row: Option<usize>,
     pub trim_values: Option<bool>,
     pub empty_string_as_null: Option<bool>,
     pub sheet_name: Option<String>,
@@ -113,6 +116,9 @@ impl Default for TableImportParseOptions {
         Self {
             delimiter: None,
             has_header: None,
+            title_row: None,
+            data_start_row: None,
+            last_data_row: None,
             trim_values: Some(false),
             empty_string_as_null: Some(true),
             sheet_name: None,
@@ -270,9 +276,37 @@ pub fn normalize_header(value: &str, index: usize) -> String {
 #[derive(Debug, Clone, Copy)]
 pub struct DelimitedParseConfig {
     pub delimiter: u8,
-    pub has_header: bool,
     pub trim_values: bool,
     pub empty_string_as_null: bool,
+    pub row_range: ImportRowRange,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ImportRowRange {
+    pub title_row: Option<usize>,
+    pub data_start_row: usize,
+    pub last_data_row: Option<usize>,
+}
+
+pub fn effective_import_row_range(options: &TableImportParseOptions) -> Result<ImportRowRange, String> {
+    let title_row = match options.title_row {
+        Some(0) => None,
+        Some(row) => Some(row),
+        None if options.has_header.unwrap_or(true) => Some(1),
+        None => None,
+    };
+    let data_start_row = options.data_start_row.unwrap_or_else(|| title_row.map_or(1, |row| row + 1));
+    let last_data_row = options.last_data_row.filter(|row| *row > 0);
+    if data_start_row == 0 {
+        return Err("Data start row must be at least 1".to_string());
+    }
+    if title_row.is_some_and(|row| row >= data_start_row) {
+        return Err("Title row must be before the data start row".to_string());
+    }
+    if last_data_row.is_some_and(|last| last < data_start_row) {
+        return Err("Last data row must be 0 or not less than the data start row".to_string());
+    }
+    Ok(ImportRowRange { title_row, data_start_row, last_data_row })
 }
 
 pub fn effective_delimited_config(
@@ -297,9 +331,9 @@ pub fn effective_delimited_config(
 
     Ok(DelimitedParseConfig {
         delimiter,
-        has_header: options.has_header.unwrap_or(true),
         trim_values: options.trim_values.unwrap_or(false),
         empty_string_as_null: options.empty_string_as_null.unwrap_or(true),
+        row_range: effective_import_row_range(options)?,
     })
 }
 
@@ -315,7 +349,12 @@ pub fn csv_value_with_config(value: &str, config: DelimitedParseConfig) -> serde
 pub fn csv_value(value: &str) -> serde_json::Value {
     csv_value_with_config(
         value,
-        DelimitedParseConfig { delimiter: b',', has_header: true, trim_values: false, empty_string_as_null: true },
+        DelimitedParseConfig {
+            delimiter: b',',
+            trim_values: false,
+            empty_string_as_null: true,
+            row_range: ImportRowRange { title_row: Some(1), data_start_row: 2, last_data_row: None },
+        },
     )
 }
 
@@ -324,72 +363,32 @@ pub fn parse_delimited_reader<R: std::io::Read>(
     config: DelimitedParseConfig,
     preview_limit: usize,
 ) -> Result<ParsedImportFile, String> {
-    let mut reader = csv::ReaderBuilder::new()
-        .delimiter(config.delimiter)
-        .has_headers(config.has_header)
-        .flexible(true)
-        .from_reader(reader);
+    let mut reader =
+        csv::ReaderBuilder::new().delimiter(config.delimiter).has_headers(false).flexible(true).from_reader(reader);
 
     let mut rows = Vec::new();
     let mut total_rows = 0;
-    let columns = if config.has_header {
-        reader
-            .headers()
-            .map_err(|e| e.to_string())?
-            .iter()
-            .enumerate()
-            .map(|(index, header)| normalize_header(header.trim_start_matches('\u{feff}'), index))
-            .collect::<Vec<_>>()
-    } else {
-        Vec::new()
-    };
-
-    let mut columns = columns;
-    if columns.is_empty() {
-        let mut records = reader.records();
-        let first_record = match records.next() {
-            Some(record) => record.map_err(|e| e.to_string())?,
-            None => return Err("Import file has no rows".to_string()),
-        };
-        columns = (0..first_record.len()).map(|index| format!("column_{}", index + 1)).collect();
-        if columns.is_empty() {
-            return Err("Import file has no columns".to_string());
-        }
-        total_rows += 1;
-        if preview_limit > 0 {
-            rows.push(
-                (0..columns.len())
-                    .map(|index| {
-                        first_record
-                            .get(index)
-                            .map(|value| csv_value_with_config(value, config))
-                            .unwrap_or(serde_json::Value::Null)
-                    })
-                    .collect(),
-            );
-        }
-        for record in records {
-            let record = record.map_err(|e| e.to_string())?;
-            total_rows += 1;
-            if rows.len() >= preview_limit {
-                continue;
-            }
-            let mut row = Vec::with_capacity(columns.len());
-            for index in 0..columns.len() {
-                row.push(
-                    record
-                        .get(index)
-                        .map(|value| csv_value_with_config(value, config))
-                        .unwrap_or(serde_json::Value::Null),
-                );
-            }
-            rows.push(row);
-        }
-        return Ok(ParsedImportFile { columns, rows, total_rows });
-    }
-
-    for record in reader.records() {
+    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;
+        if config.row_range.title_row == Some(row_number) {
+            columns = record
+                .iter()
+                .enumerate()
+                .map(|(index, header)| normalize_header(header.trim_start_matches('\u{feff}'), index))
+                .collect();
+            continue;
+        }
+        if row_number < config.row_range.data_start_row {
+            continue;
+        }
+        if config.row_range.last_data_row.is_some_and(|last| row_number > last) {
+            break;
+        }
+        if columns.is_empty() {
+            columns = (0..record.len()).map(|index| format!("column_{}", index + 1)).collect();
+        }
         total_rows += 1;
         if rows.len() >= preview_limit {
             continue;
@@ -402,7 +401,12 @@ pub fn parse_delimited_reader<R: std::io::Read>(
         }
         rows.push(row);
     }
-
+    if columns.is_empty() {
+        return Err("Import file has no columns in the selected row range".to_string());
+    }
+    if total_rows == 0 {
+        return Err("Import file has no data rows in the selected row range".to_string());
+    }
     Ok(ParsedImportFile { columns, rows, total_rows })
 }
 
@@ -580,47 +584,29 @@ pub fn parse_xlsx_file_with_options(
         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 mut rows_iter = range.rows();
-    let has_header = options.has_header.unwrap_or(true);
-    let columns = if has_header {
-        let header = rows_iter.next().ok_or_else(|| "Import file has no rows".to_string())?;
-        header
-            .iter()
-            .enumerate()
-            .map(|(index, cell)| normalize_header(&xlsx_cell_label(cell), index))
-            .collect::<Vec<_>>()
-    } else {
-        let first_row = rows_iter.next().ok_or_else(|| "Import file has no rows".to_string())?;
-        let columns = (0..first_row.len()).map(|index| format!("column_{}", index + 1)).collect::<Vec<_>>();
-        let mut rows = Vec::new();
-        if preview_limit > 0 {
-            rows.push(
-                (0..columns.len())
-                    .map(|index| first_row.get(index).map(xlsx_cell_value).unwrap_or(serde_json::Value::Null))
-                    .collect::<Vec<_>>(),
-            );
-        }
-        let mut total_rows = 1;
-        for source_row in rows_iter {
-            total_rows += 1;
-            if rows.len() >= preview_limit {
-                continue;
-            }
-            let mut row = Vec::with_capacity(columns.len());
-            for index in 0..columns.len() {
-                row.push(source_row.get(index).map(xlsx_cell_value).unwrap_or(serde_json::Value::Null));
-            }
-            rows.push(row);
-        }
-        return Ok(ParsedImportFile { columns, rows, total_rows });
-    };
-    if columns.is_empty() {
-        return Err("Import file has no columns".to_string());
-    }
-
+    let row_range = effective_import_row_range(options)?;
+    let mut columns = Vec::new();
     let mut rows = Vec::new();
     let mut total_rows = 0;
-    for source_row in rows_iter {
+    for (index, source_row) in range.rows().enumerate() {
+        let row_number = index + 1;
+        if row_range.title_row == Some(row_number) {
+            columns = source_row
+                .iter()
+                .enumerate()
+                .map(|(index, cell)| normalize_header(&xlsx_cell_label(cell), index))
+                .collect();
+            continue;
+        }
+        if row_number < row_range.data_start_row {
+            continue;
+        }
+        if row_range.last_data_row.is_some_and(|last| row_number > last) {
+            break;
+        }
+        if columns.is_empty() {
+            columns = (0..source_row.len()).map(|index| format!("column_{}", index + 1)).collect();
+        }
         total_rows += 1;
         if rows.len() >= preview_limit {
             continue;
@@ -631,7 +617,12 @@ pub fn parse_xlsx_file_with_options(
         }
         rows.push(row);
     }
-
+    if columns.is_empty() {
+        return Err("Import file has no columns in the selected row range".to_string());
+    }
+    if total_rows == 0 {
+        return Err("Import file has no data rows in the selected row range".to_string());
+    }
     Ok(ParsedImportFile { columns, rows, total_rows })
 }
 
@@ -1173,28 +1164,33 @@ fn delimited_columns_and_first_record<R: std::io::Read>(
     reader: &mut csv::Reader<R>,
     config: DelimitedParseConfig,
 ) -> Result<(Vec<String>, Option<csv::StringRecord>), String> {
-    if config.has_header {
-        let columns = reader
-            .headers()
-            .map_err(|e| e.to_string())?
-            .iter()
-            .enumerate()
-            .map(|(index, header)| normalize_header(header.trim_start_matches('\u{feff}'), index))
-            .collect::<Vec<_>>();
+    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;
+        if config.row_range.title_row == Some(row_number) {
+            columns = record
+                .iter()
+                .enumerate()
+                .map(|(index, header)| normalize_header(header.trim_start_matches('\u{feff}'), index))
+                .collect();
+            continue;
+        }
+        if row_number < config.row_range.data_start_row {
+            continue;
+        }
+        if config.row_range.last_data_row.is_some_and(|last| row_number > last) {
+            break;
+        }
+        if columns.is_empty() {
+            columns = (0..record.len()).map(|index| format!("column_{}", index + 1)).collect();
+        }
         if columns.is_empty() {
             return Err("Import file has no columns".to_string());
         }
-        return Ok((columns, None));
+        return Ok((columns, Some(record)));
     }
-
-    let mut records = reader.records();
-    let first_record =
-        records.next().transpose().map_err(|e| e.to_string())?.ok_or_else(|| "Import file has no rows".to_string())?;
-    let columns = (0..first_record.len()).map(|index| format!("column_{}", index + 1)).collect::<Vec<_>>();
-    if columns.is_empty() {
-        return Err("Import file has no columns".to_string());
-    }
-    Ok((columns, Some(first_record)))
+    Err("Import file has no data rows in the selected row range".to_string())
 }
 
 pub async fn preview_table_import_file_with_request(
@@ -1393,11 +1389,8 @@ where
                 ));
             }
         };
-        let mut reader = csv::ReaderBuilder::new()
-            .delimiter(config.delimiter)
-            .has_headers(config.has_header)
-            .flexible(true)
-            .from_reader(file);
+        let mut reader =
+            csv::ReaderBuilder::new().delimiter(config.delimiter).has_headers(false).flexible(true).from_reader(file);
         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)),
@@ -1414,7 +1407,12 @@ where
             pending_rows.push(delimited_record_to_row(&record, columns.len(), config));
         }
 
+        let mut source_row_number = config.row_range.data_start_row;
         for record in reader.records() {
+            source_row_number += 1;
+            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(),
@@ -1692,6 +1690,40 @@ mod tests {
         assert_eq!(parsed.rows[1], vec![serde_json::json!("2"), serde_json::Value::Null]);
     }
 
+    #[test]
+    fn parses_delimited_text_with_custom_title_and_data_rows() {
+        let options = TableImportParseOptions {
+            title_row: Some(2),
+            data_start_row: Some(4),
+            last_data_row: Some(5),
+            ..TableImportParseOptions::default()
+        };
+        let parsed = parse_delimited_bytes_with_options(
+            b"report,ignored\nid,name\nnotes,ignored\n1,Ada\n2,Grace\nsummary,2\n",
+            TableImportSourceFormat::Csv,
+            &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"), serde_json::json!("Ada")]);
+        assert_eq!(parsed.rows[1], vec![serde_json::json!("2"), serde_json::json!("Grace")]);
+    }
+
+    #[test]
+    fn rejects_title_row_inside_data_range() {
+        let options = TableImportParseOptions {
+            title_row: Some(2),
+            data_start_row: Some(1),
+            last_data_row: Some(3),
+            ..TableImportParseOptions::default()
+        };
+
+        assert!(effective_import_row_range(&options).unwrap_err().contains("before the data start row"));
+    }
+
     #[test]
     fn parses_json_array_objects_with_union_columns() {
         let parsed = parse_json_bytes(br#"[{"id":1,"name":"Ada"},{"id":2,"active":true}]"#, 10).unwrap();
@@ -1752,6 +1784,37 @@ mod tests {
         let _ = std::fs::remove_file(path);
     }
 
+    #[test]
+    fn parses_excel_with_custom_title_and_data_rows() {
+        let path = std::env::temp_dir().join(format!("dbx-table-import-rows-{}.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 parsed = parse_xlsx_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")]);
+        let _ = std::fs::remove_file(path);
+    }
+
     #[test]
     fn builds_create_table_plan_from_import_sample() {
         let data = ParsedImportFile {