feat(export): support column selection in SQL exports

Closes #9475
This commit is contained in:
t8y2 committed 2026-09-27 22:37:50 +00:00
1 parent e9998e2806
commit 0a6ab8d360
28 files changed
+923 -85

No files matched your search

@@ -0,0 +1,188 @@
import { computed, ref } from "vue";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { useDataGridExport, type UseDataGridExportOptions } from "@/composables/useDataGridExport";
import { useExportTracker } from "@/composables/useExportTracker";
import { sqlExportColumnChoices } from "@/lib/export/sqlExportColumns";
import { showSqlInsertModeDialog } from "@/lib/export/sqlInsertMode";
import { formatSqlInsert } from "@/lib/export/exportFormats";
import { saveTextFile } from "@/lib/export/saveTextFile";
import * as api from "@/lib/backend/api";
import type { QueryResult } from "@/types/database";
const mocks = vi.hoisted(() => ({ native: true, toast: vi.fn() }));
vi.mock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => mocks.native }));
vi.mock("@tauri-apps/plugin-dialog", () => ({ save: vi.fn().mockResolvedValue("/exports/result.sql") }));
vi.mock("@/lib/backend/api", () => ({ startQueryResultExport: vi.fn(), startTableExport: vi.fn(), cancelQueryResultExport: vi.fn(), cancelTableExport: vi.fn() }));
vi.mock("@/composables/useToast", () => ({ useToast: () => ({ toast: mocks.toast }) }));
vi.mock("@/composables/useDataGridExtractor", () => ({ useDataGridExtractor: () => ({ copyWithExtractor: vi.fn(), previewWithExtractor: vi.fn(), canCopyWithExtractor: vi.fn() }) }));
vi.mock("@/stores/settingsStore", () => ({ useSettingsStore: () => ({ editorSettings: { exportBatchSize: 1000, globalDateTimeExportFormat: "", numericColumnRightAlign: true } }) }));
vi.mock("vue-i18n", () => ({ useI18n: () => ({ t: (key: string) => key }) }));
vi.mock("@/i18n", () => ({ default: { install() {} } }));
vi.mock("@/lib/export/sqlInsertMode", () => ({ showSqlInsertModeDialog: vi.fn() }));
vi.mock("@/lib/export/exportFormats", () => ({ formatSqlInsert: vi.fn().mockResolvedValue("INSERT INTO users VALUES ('Ada');"), formatTsv: vi.fn() }));
vi.mock("@/lib/export/saveTextFile", async (importOriginal) => ({ ...(await importOriginal<object>()), saveTextFile: vi.fn() }));
function createOptions(overrides: Partial<UseDataGridExportOptions> = {}): UseDataGridExportOptions {
const items = [
{ id: 7, sourceIndex: 0, data: [1, "Ada"], isNew: false, isDeleted: false, isDirtyCol: [], status: "" },
{ id: 8, sourceIndex: 1, data: [2, "Lin"], isNew: false, isDeleted: false, isDirtyCol: [], status: "" },
];
return {
columns: computed(() => ["id", "name"]),
displayItems: computed(() => items),
sql: computed(() => "SELECT id, name FROM users"),
tableMeta: computed(() => ({
tableName: "users",
primaryKeys: [],
columns: [
{ name: "id", data_type: "int" },
{ name: "name", data_type: "text" },
],
})),
databaseType: computed(() => "postgres"),
connectionId: computed(() => "conn"),
database: computed(() => "dbx"),
context: computed(() => "results"),
sourceColumns: computed(() => ["id", "name"]),
columnTypes: computed(() => ["int4", "text"]),
whereInput: computed(() => undefined),
orderBy: computed(() => undefined),
exportBatchSize: computed(() => 1000),
hasCellSelection: computed(() => false),
selectedCells: computed(() => ({ columns: [], rows: [] })),
selectedCellMatrix: computed(() => null),
selectedRange: computed(() => null),
contextCell: ref(null),
contextSelectionIsSynthetic: ref(false),
getRowItem: (id) => items.find((item) => item.id === id),
selectedRowIds: ref(new Set<number>()),
hasRowSelection: computed(() => false),
queryResultExportRequest: vi.fn(async (request) => ({ ...request, connectionId: "conn", database: "dbx", databaseType: "postgres", sql: "SELECT id, name FROM users", queryBaseSql: "SELECT id, name FROM users", useAgentCursor: false, pageSize: 1000, keysetOptimizationEnabled: true })),
...overrides,
};
}
describe("SQL export column selection across entrypoints", () => {
beforeEach(() => {
vi.clearAllMocks();
mocks.native = true;
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "single", selectedColumns: [sqlExportColumnChoices(["id", "name"])[1]!] });
const done = { exportId: "export", tableName: "users", rowsExported: 2, totalRows: 2, status: "Done" as const };
vi.mocked(api.startQueryResultExport).mockResolvedValue(done);
vi.mocked(api.startTableExport).mockResolvedValue(done);
});
afterEach(() => {
const tracker = useExportTracker();
for (const task of tracker.tasks.value) tracker.removeTask(task.exportId);
});
it("passes full-result selection to backend without changing query, paging or metadata", async () => {
const choices = sqlExportColumnChoices(["id", "name", "id"]);
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "single", selectedColumns: [choices[2]!] });
const state = useDataGridExport(createOptions({ allColumns: computed(() => ["id", "name", "id"]), allColumnTypes: computed(() => ["int", "text", "bigint"]) }));
await state.exportSql();
expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: false, columns: choices });
expect(api.startQueryResultExport).toHaveBeenCalledWith(expect.objectContaining({ selectedColumns: [choices[2]!], exportColumnTypes: ["int", "text", "bigint"], insertMode: "single", keysetOptimizationEnabled: true, sql: "SELECT id, name FROM users" }), expect.any(Function));
});
it("preserves full table paging keys and split options in the backend request", async () => {
const selectedColumns = [sqlExportColumnChoices(["id", "name"])[1]!];
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "batch", selectedColumns, splitMaxMb: 128 });
await useDataGridExport(createOptions({ context: computed(() => "table-data") })).exportSql();
expect(api.startTableExport).toHaveBeenCalledWith(expect.objectContaining({ columns: ["id", "name"], columnTypes: ["int4", "text"], selectedColumns, splitMaxMb: 128 }), expect.any(Function));
expect(api.startQueryResultExport).not.toHaveBeenCalled();
});
it.each(["page", "selected"] as const)("projects %s rows and types together without requerying", async (scope) => {
const state = useDataGridExport(createOptions());
if (scope === "page") await state.exportCurrentPageSql();
else await state.exportSql([8]);
expect(formatSqlInsert).toHaveBeenCalledWith(expect.objectContaining({ columns: ["name"], columnTypes: ["text"], rows: scope === "page" ? [["Ada"], ["Lin"]] : [["Lin"]], insertMode: "single" }));
expect(api.startQueryResultExport).not.toHaveBeenCalled();
expect(api.startTableExport).not.toHaveBeenCalled();
expect(saveTextFile).toHaveBeenCalledOnce();
});
it("keeps second duplicate, spatial metadata and raw types aligned after internal-key removal", async () => {
const names = ["__DBX_ROWID", "id", "id", "shape"];
const choices = sqlExportColumnChoices(names);
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "batch", selectedColumns: [choices[2]!, choices[3]!] });
const result = { columns: names, column_types: ["ROWID", "int", "bigint", "geometry"], rows: [["key", 1, 20, "POINT(1 2)"]], hidden_column_indexes: [0], spatial_columns: [{ column_index: 3, srid: 4326 }], spatial_values: [[null, null, null, 4326]] } as QueryResult;
await useDataGridExport(createOptions({ databaseType: computed(() => "oracle"), allColumns: computed(() => names), hasCompleteLocalResult: computed(() => true), completeLocalResult: computed(() => result) })).exportSql();
expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: false, columns: choices.slice(1) });
expect(formatSqlInsert).toHaveBeenCalledWith(expect.objectContaining({ columns: ["id", "shape"], columnTypes: ["bigint", "geometry"], rows: [[20, "POINT(1 2)"]], spatialColumns: [{ column_index: 1, srid: 4326 }], spatialValues: [[null, 4326]] }));
expect(api.startQueryResultExport).not.toHaveBeenCalled();
});
it("applies the selection to the Web full-result fallback", async () => {
mocks.native = false;
const fullExportResult = vi.fn(async () => ({ columns: ["id", "name"], column_types: ["int", "varchar"], rows: [[3, "Grace"]] }) as QueryResult);
await useDataGridExport(createOptions({ fullExportResult })).exportSql();
expect(fullExportResult).toHaveBeenCalledOnce();
expect(formatSqlInsert).toHaveBeenCalledWith(expect.objectContaining({ columns: ["name"], columnTypes: ["text"], rows: [["Grace"]] }));
});
it("does not remap reordered full-table results by visible positions", async () => {
mocks.native = false;
const fullExportResult = vi.fn(async () => ({ columns: ["name", "id"], column_types: ["varchar", "bigint"], rows: [["Grace", 3]] }) as QueryResult);
await useDataGridExport(createOptions({ context: computed(() => "table-data"), tableMeta: computed(() => ({ tableName: "users", catalog: "external", primaryKeys: [], columns: [] })), fullExportResult })).exportSql();
expect(formatSqlInsert).toHaveBeenCalledWith(expect.objectContaining({ columns: ["name"], columnTypes: ["varchar"], rows: [["Grace"]] }));
});
it("omits generated MySQL columns from the chooser but preserves identity and expression defaults", async () => {
vi.mocked(showSqlInsertModeDialog).mockResolvedValue(null);
const names = ["id", "generated", "defaulted", "identity"];
await useDataGridExport(
createOptions({
context: computed(() => "table-data"),
databaseType: computed(() => "mysql"),
columns: computed(() => names),
sourceColumns: computed(() => names),
tableMeta: computed(() => ({
tableName: "users",
primaryKeys: ["id"],
columns: [
{ name: "id", data_type: "int", extra: "auto_increment" },
{ name: "generated", data_type: "text", extra: "VIRTUAL GENERATED" },
{ name: "defaulted", data_type: "timestamp", extra: "DEFAULT_GENERATED" },
{ name: "identity", data_type: "int", extra: "auto_increment" },
],
})),
}),
).exportSql();
expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: true, columns: sqlExportColumnChoices(names).filter((column) => column.name !== "generated") });
});
it("omits PostgreSQL tsvector fields using query metadata", async () => {
vi.mocked(showSqlInsertModeDialog).mockResolvedValue(null);
await useDataGridExport(createOptions({ allColumns: computed(() => ["id", "search"]), allColumnTypes: computed(() => ["int", "pg_catalog.tsvector"]) })).exportSql();
expect(showSqlInsertModeDialog).toHaveBeenCalledWith({ allowSplit: false, columns: sqlExportColumnChoices(["id"]) });
});
it("does not export after cancellation or an invalid empty selection", async () => {
const state = useDataGridExport(createOptions());
vi.mocked(showSqlInsertModeDialog).mockResolvedValue(null);
await state.exportSql();
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "batch", selectedColumns: [] });
await state.exportCurrentPageSql();
expect(api.startQueryResultExport).not.toHaveBeenCalled();
expect(formatSqlInsert).not.toHaveBeenCalled();
expect(saveTextFile).not.toHaveBeenCalled();
expect(mocks.toast).toHaveBeenCalledWith("grid.exportFailed", 5000);
});
it("keeps legacy omitted selection behavior", async () => {
vi.mocked(showSqlInsertModeDialog).mockResolvedValue({ insertMode: "batch" });
await useDataGridExport(createOptions()).exportCurrentPageSql();
expect(formatSqlInsert).toHaveBeenCalledWith(
expect.objectContaining({
columns: ["id", "name"],
rows: [
[1, "Ada"],
[2, "Lin"],
],
}),
);
});
});
@@ -15,7 +15,8 @@ import { clipboardLineEndings, copyToClipboard } from "@/lib/common/clipboard";
import { clearDataGridClipboardCopy, rememberDataGridClipboardCopy } from "@/lib/dataGrid/dataGridClipboard";
import { buildDataGridCopyInsertStatement, type DataGridCopyInsertMode, type DataGridTableMeta } from "@/lib/dataGrid/dataGridSql";
import { formatSqlInsert, formatTsv } from "@/lib/export/exportFormats";
import { showSqlInsertModeDialog, type SqlExportOptions, type SqlInsertMode } from "@/lib/export/sqlInsertMode";
import { showSqlInsertModeDialog, type SqlExportColumnSelection, type SqlExportOptions, type SqlInsertMode } from "@/lib/export/sqlInsertMode";
import { resolveSqlExportColumnIndexes, sqlExportColumnChoices } from "@/lib/export/sqlExportColumns";
import { summarizeExportRows } from "@/lib/export/exportDiagnostics";
import { appendDebugLog, appendNativeProcessMemoryLog, getBrowserMemorySnapshot, isDebugLoggingEnabled } from "@/lib/backend/debugLog";
import { uuid } from "@/lib/common/utils";
@@ -339,7 +340,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
});
}
function normalizeCompleteLocalResult(result: QueryResult): { columns: string[]; columnTypes: string[]; columnComments: Array<string | undefined>; rows: CellValue[][]; mongoCopyDocuments?: unknown[] } {
function normalizeCompleteLocalResult(result: QueryResult): { columns: string[]; columnTypes: string[]; columnComments: Array<string | undefined>; rows: CellValue[][]; mongoCopyDocuments?: unknown[]; spatialColumns?: QueryResult["spatial_columns"]; spatialValues?: QueryResult["spatial_values"] } {
const editorSettings = useSettingsStore().editorSettings;
if (databaseType.value === "mongodb") {
const projected = projectResultColumns(result, columns.value);
@@ -350,6 +351,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
columnComments: commentsForExportColumns(projected.columns),
rows,
mongoCopyDocuments: result.mongo_copy_documents?.slice(0, rows.length),
spatialColumns: projected.spatialColumns,
spatialValues: projected.spatialValues?.slice(0, rows.length),
};
}
@@ -357,6 +360,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
const exportedColumnIndexes = result.columns.map((_, index) => index).filter((index) => !hiddenColumnIndexes.has(index));
const hasHiddenColumns = exportedColumnIndexes.length !== result.columns.length;
const rows = editorSettings.exportRowLimitEnabled ? result.rows.slice(0, editorSettings.exportRowLimit) : result.rows;
const targetIndexBySource = new Map(exportedColumnIndexes.map((sourceIndex, index) => [sourceIndex, index]));
// Internal key columns are query-only metadata. Keep every user column,
// including columns hidden manually in the grid, while preserving alignment.
@@ -366,6 +370,11 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
columnComments: hasHiddenColumns ? exportedColumnIndexes.map((index) => allXlsxColumnComments.value[index]) : [...allXlsxColumnComments.value],
rows: hasHiddenColumns ? rows.map((row) => exportedColumnIndexes.map((index) => row[index])) : rows,
mongoCopyDocuments: result.mongo_copy_documents?.slice(0, rows.length),
spatialColumns: result.spatial_columns?.flatMap((column) => {
const columnIndex = targetIndexBySource.get(column.column_index);
return columnIndex === undefined ? [] : [{ ...column, column_index: columnIndex }];
}),
spatialValues: result.spatial_values?.slice(0, rows.length).map((row) => exportedColumnIndexes.map((index) => row[index] ?? null)),
};
}
@@ -473,8 +482,8 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
formatDateTime && !preserveMongoExtendedJson,
),
columnComments,
spatialColumns: completeLocalResult.value.spatial_columns,
spatialValues: completeLocalResult.value.spatial_values,
spatialColumns: normalized.spatialColumns,
spatialValues: normalized.spatialValues,
};
}
const commentHeader = buildXlsxHeaderOverrides(columns.value, visibleXlsxColumnComments.value, headerMode);
@@ -1378,11 +1387,11 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
tableName: meta.tableName,
filePath: outputPath,
format,
...(format === "sql" && sqlExportOptions ? { insertMode: sqlExportOptions.insertMode, splitMaxMb: sqlExportOptions.splitMaxMb } : {}),
...(format === "sql" && sqlExportOptions ? { insertMode: sqlExportOptions.insertMode, splitMaxMb: sqlExportOptions.splitMaxMb, selectedColumns: sqlExportOptions.selectedColumns } : {}),
csvQuoteMode: editorSettings.csvQuoteMode,
columns: columns.value,
columns: format === "sql" ? effectiveColumns(sourceColumns.value, columns.value).map((column, index) => column ?? columns.value[index]!) : columns.value,
columnTypes: columnTypes.value,
...(format === "sql" ? { columnExtras: sqlExportColumnExtras(columns.value) } : {}),
...(format === "sql" ? { columnExtras: sqlExportColumnExtras(effectiveColumns(sourceColumns.value, columns.value).map((column, index) => column ?? columns.value[index]!)) } : {}),
columnComments: format === "xlsx" ? buildXlsxHeaderOverrides(columns.value, visibleXlsxColumnComments.value, headerMode) : undefined,
primaryKeys: meta.primaryKeys,
...sqlExportPrimaryKeyOptions(),
@@ -1421,7 +1430,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return true;
}
async function exportQueryResultViaBackend(format: "csv" | "xlsx" | "json" | "txt" | "sql", rowIds?: number[], includeSqlSheet = false, headerMode: XlsxHeaderMode = "name", autoFilter = true, insertMode?: SqlInsertMode): Promise<boolean> {
async function exportQueryResultViaBackend(format: "csv" | "xlsx" | "json" | "txt" | "sql", rowIds?: number[], includeSqlSheet = false, headerMode: XlsxHeaderMode = "name", autoFilter = true, sqlExportOptions?: SqlExportOptions): Promise<boolean> {
if (rowIds !== undefined || context.value !== "results" || !queryResultExportRequest) {
return false;
}
@@ -1453,12 +1462,13 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
exportTableName: format === "sql" ? tableMeta.value?.tableName : undefined,
exportColumnTypes: format === "sql" ? allColumnTypes.value?.map((type) => type ?? null) : undefined,
exportColumnExtras: format === "sql" ? sqlExportColumnExtras(allColumns.value) : undefined,
...(format === "sql" && insertMode ? { insertMode } : {}),
...(format === "sql" && sqlExportOptions ? { insertMode: sqlExportOptions.insertMode } : {}),
});
const columnComments = format === "xlsx" ? buildXlsxHeaderOverrides(allColumns.value, allXlsxColumnComments.value, headerMode) : undefined;
const request = baseRequest
? {
...baseRequest,
...(format === "sql" ? { selectedColumns: sqlExportOptions?.selectedColumns } : {}),
csvQuoteMode: useSettingsStore().editorSettings.csvQuoteMode,
...sqlExportPrimaryKeyOptions(),
dateTimeFormat: useSettingsStore().editorSettings.globalDateTimeExportFormat || undefined,
@@ -1537,9 +1547,23 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
return true;
}
async function exportQueryResultSqlViaBackend(rowIds: number[] | undefined, insertMode: SqlInsertMode): Promise<boolean> {
async function exportQueryResultSqlViaBackend(rowIds: number[] | undefined, sqlExportOptions: SqlExportOptions): Promise<boolean> {
if (!isTauriRuntime()) return false;
return exportQueryResultViaBackend("sql", rowIds, false, "name", true, insertMode);
return exportQueryResultViaBackend("sql", rowIds, false, "name", true, sqlExportOptions);
}
function sqlExportChoices(fullResult: boolean): SqlExportColumnSelection[] {
const names = context.value === "table-data" ? effectiveColumns(sourceColumns.value, columns.value) : fullResult ? allColumns.value : columns.value;
const excluded = new Set((sqlExportExcludedColumns() ?? []).map(normalizeColumnName));
const types = fullResult && context.value === "results" ? allColumnTypes.value : columnTypes.value;
const metadataByName = new Map((tableMeta.value?.columns ?? []).map((column) => [normalizeColumnName(column.name), column]));
return sqlExportColumnChoices(names).filter((column) => {
if (excluded.has(normalizeColumnName(column.name)) || usesSyntheticRowIdKey(databaseType.value, [column.name])) return false;
const metadata = metadataByName.get(normalizeColumnName(column.name));
if (databaseType.value === "mysql" && /\b(?:virtual|stored|persistent)\s+generated\b|\bgenerated\s+always\s+as\s*\(/i.test(metadata?.extra ?? "")) return false;
const columnType = (metadata?.data_type || types?.[column.sourceIndex])?.trim().replace(/^"|"$/g, "").toLowerCase();
return databaseType.value !== "postgres" || (columnType !== "tsvector" && !columnType?.endsWith(".tsvector"));
});
}
async function exportSql(rowIds?: number[]) {
@@ -1568,12 +1592,12 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
},
true,
);
const selectedSqlExportOptions = (await showSqlInsertModeDialog({ allowSplit: rowIds === undefined && context.value === "table-data" })) as SqlExportOptions | SqlInsertMode | null;
const selectedSqlExportOptions = (await showSqlInsertModeDialog({ allowSplit: rowIds === undefined && context.value === "table-data", columns: sqlExportChoices(rowIds === undefined) })) as SqlExportOptions | SqlInsertMode | null;
if (selectedSqlExportOptions === null) {
logExportStage("cancelled", { stage: "insert-mode-dialog" });
return;
}
const sqlExportOptions = typeof selectedSqlExportOptions === "string" ? { insertMode: selectedSqlExportOptions } : selectedSqlExportOptions;
const sqlExportOptions: SqlExportOptions = typeof selectedSqlExportOptions === "string" ? { insertMode: selectedSqlExportOptions } : selectedSqlExportOptions;
const insertMode = sqlExportOptions.insertMode;
logExportStage("mode-selected", { insertMode, splitMaxMb: sqlExportOptions.splitMaxMb });
try {
@@ -1588,7 +1612,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
// Step 2: query-result context — NEW backend streaming with background task
logExportStage("query-backend-export-start");
const handledQueryByBackend = await exportQueryResultSqlViaBackend(rowIds, insertMode);
const handledQueryByBackend = await exportQueryResultSqlViaBackend(rowIds, sqlExportOptions);
logExportStage("query-backend-export-finished", { handledByBackend: handledQueryByBackend });
if (handledQueryByBackend) {
logExportStage("done", { path: "query-backend" });
@@ -1608,7 +1632,7 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
);
logExportStage("row-remap-start");
const exportData = sqlInsertExportData(result);
const exportData = sqlInsertExportData(result, sqlExportOptions.selectedColumns);
logExportStage("row-remap-done", {
columns: exportData.columns.length,
rows: exportData.rows.length,
@@ -1653,12 +1677,13 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
async function exportCurrentPageSql() {
await runExclusiveExport(async () => {
const selectedSqlExportOptions = (await showSqlInsertModeDialog()) as SqlExportOptions | SqlInsertMode | null;
const selectedSqlExportOptions = (await showSqlInsertModeDialog({ columns: sqlExportChoices(false) })) as SqlExportOptions | SqlInsertMode | null;
if (selectedSqlExportOptions === null) return;
const insertMode = typeof selectedSqlExportOptions === "string" ? selectedSqlExportOptions : selectedSqlExportOptions.insertMode;
const sqlExportOptions: SqlExportOptions = typeof selectedSqlExportOptions === "string" ? { insertMode: selectedSqlExportOptions } : selectedSqlExportOptions;
const insertMode = sqlExportOptions.insertMode;
try {
const result = await resultToExport(undefined, undefined, false, false);
const exportData = sqlInsertExportData(result);
const exportData = sqlInsertExportData(result, sqlExportOptions.selectedColumns);
const content = await formatSqlInsert({
databaseType: databaseType.value,
identifierQuote: options.identifierQuote?.value,
@@ -1686,7 +1711,10 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
await copyText(sql.value);
}
function sqlInsertExportData(result: { columns: string[]; rows: CellValue[][]; spatialColumns?: QueryResult["spatial_columns"]; spatialValues?: QueryResult["spatial_values"] }): {
function sqlInsertExportData(
result: { columns: string[]; columnTypes?: Array<string | undefined>; rows: CellValue[][]; spatialColumns?: QueryResult["spatial_columns"]; spatialValues?: QueryResult["spatial_values"] },
selectedColumns?: SqlExportColumnSelection[],
): {
columns: string[];
columnTypes?: Array<string | undefined>;
columnExtras?: Array<string | null>;
@@ -1694,9 +1722,12 @@ export function useDataGridExport(options: UseDataGridExportOptions) {
spatialValues?: QueryResult["spatial_values"];
rows: CellValue[][];
} {
const exportColumns = context.value === "table-data" && tableMeta.value ? effectiveColumns(sourceColumns.value, result.columns) : result.columns;
const columnIndexes = exportColumns.map((column, index) => ({ column, index })).filter((item): item is { column: string; index: number } => !!item.column);
const exportColumnTypes = columnTypes.value?.length === result.columns.length ? columnTypes.value : undefined;
const matchesVisibleColumns = result.columns.length === columns.value.length && result.columns.every((column, index) => column === columns.value[index]);
const exportColumns = context.value === "table-data" && tableMeta.value && matchesVisibleColumns ? effectiveColumns(sourceColumns.value, result.columns) : result.columns;
const columnIndexes = resolveSqlExportColumnIndexes(exportColumns, selectedColumns)
.map((index) => ({ column: exportColumns[index], index }))
.filter((item): item is { column: string; index: number } => !!item.column);
const exportColumnTypes = matchesVisibleColumns && columnTypes.value?.length === result.columns.length ? columnTypes.value : result.columnTypes?.length === result.columns.length ? result.columnTypes : undefined;
const metaColumns = tableMeta.value?.columns;
const exportColumnExtras = metaColumns?.length ? exportColumns.map((column) => (column ? (metaColumns.find((meta) => normalizeColumnName(meta.name) === normalizeColumnName(column))?.extra ?? null) : null)) : undefined;
const indexBySource = new Map(columnIndexes.map((item, index) => [item.index, index]));