feat: export query results to CSV, JSON, SQL, XLSX, or MQL (#405)

* feat: export query results to CSV, JSON, SQL, XLSX, or MQL

* fix: address review issues in export query results

* i18n: add vi, zh-Hans, tr translations for export query results strings

Author: datlechin

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Export query results directly to CSV, JSON, SQL, XLSX, or MQL via File menu, context menu, or toolbar
 - Pro license gating for Safe Mode (Touch ID) and XLSX export
 - License activation dialog
 

TablePro/Core/Plugins/QueryResultExportDataSource.swift

@@ -0,0 +1,80 @@
+//
+//  QueryResultExportDataSource.swift
+//  TablePro
+//
+
+import Foundation
+import os
+import TableProPluginKit
+
+/// In-memory `PluginExportDataSource` backed by a RowBuffer snapshot.
+/// Allows export plugins (CSV, JSON, SQL, XLSX, MQL) to export query results
+/// without modification to the plugins themselves.
+final class QueryResultExportDataSource: PluginExportDataSource, @unchecked Sendable {
+    let databaseTypeId: String
+
+    private let columns: [String]
+    private let columnTypeNames: [String]
+    private let rows: [[String?]]
+    private let driver: DatabaseDriver?
+
+    private static let logger = Logger(subsystem: "com.TablePro", category: "QueryResultExportDataSource")
+
+    init(rowBuffer: RowBuffer, databaseType: DatabaseType, driver: DatabaseDriver?) {
+        self.databaseTypeId = databaseType.rawValue
+        self.driver = driver
+
+        // Snapshot data at init time for thread safety
+        self.columns = rowBuffer.columns
+        self.columnTypeNames = rowBuffer.columnTypes.map { $0.rawType ?? "" }
+        self.rows = rowBuffer.rows.map { $0.values }
+    }
+
+    func fetchRows(table: String, databaseName: String, offset: Int, limit: Int) async throws -> PluginQueryResult {
+        let start = min(offset, rows.count)
+        let end = min(start + limit, rows.count)
+        let slice = Array(rows[start ..< end])
+
+        return PluginQueryResult(
+            columns: columns,
+            columnTypeNames: columnTypeNames,
+            rows: slice,
+            rowsAffected: 0,
+            executionTime: 0
+        )
+    }
+
+    func fetchApproximateRowCount(table: String, databaseName: String) async throws -> Int? {
+        rows.count
+    }
+
+    func quoteIdentifier(_ identifier: String) -> String {
+        if let driver {
+            return driver.quoteIdentifier(identifier)
+        }
+        return "\"\(identifier.replacingOccurrences(of: "\"", with: "\"\""))\""
+    }
+
+    func escapeStringLiteral(_ value: String) -> String {
+        if let driver {
+            return driver.escapeStringLiteral(value)
+        }
+        return value.replacingOccurrences(of: "'", with: "''")
+    }
+
+    func fetchTableDDL(table: String, databaseName: String) async throws -> String {
+        ""
+    }
+
+    func execute(query: String) async throws -> PluginQueryResult {
+        throw ExportError.exportFailed("Execute is not supported for in-memory query result export")
+    }
+
+    func fetchDependentSequences(table: String, databaseName: String) async throws -> [PluginSequenceInfo] {
+        []
+    }
+
+    func fetchDependentTypes(table: String, databaseName: String) async throws -> [PluginEnumTypeInfo] {
+        []
+    }
+}

TablePro/Core/Services/Export/ExportService.swift

@@ -62,14 +62,20 @@ final class ExportService {
 
     var state = ExportState()
 
-    private let driver: DatabaseDriver
+    private let driver: DatabaseDriver?
     private let databaseType: DatabaseType
 
     init(driver: DatabaseDriver, databaseType: DatabaseType) {
         self.driver = driver
         self.databaseType = databaseType
     }
 
+    /// Convenience initializer for query results export (no driver needed).
+    init(databaseType: DatabaseType) {
+        self.driver = nil
+        self.databaseType = databaseType
+    }
+
     // MARK: - Cancellation
 
     private let isCancelledLock = NSLock()
@@ -120,8 +126,12 @@ final class ExportService {
             currentProgress = nil
         }
 
+        guard let driver else {
+            throw ExportError.notConnected
+        }
+
         // Fetch total row counts
-        state.totalRows = await fetchTotalRowCount(for: tables)
+        state.totalRows = await fetchTotalRowCount(for: tables, driver: driver)
 
         // Create data source adapter
         let dataSource = ExportDataSourceAdapter(driver: driver, databaseType: databaseType)
@@ -183,9 +193,89 @@ final class ExportService {
         state.progress = 1.0
     }
 
+    // MARK: - Query Results Export
+
+    func exportQueryResults(
+        rowBuffer: RowBuffer,
+        config: ExportConfiguration,
+        to url: URL
+    ) async throws {
+        guard let plugin = PluginManager.shared.exportPlugins[config.formatId] else {
+            throw ExportError.formatNotFound(config.formatId)
+        }
+
+        let totalRows = rowBuffer.rows.count
+        state = ExportState(isExporting: true, totalTables: 1, totalRows: totalRows)
+        isCancelled = false
+
+        defer {
+            state.isExporting = false
+            isCancelled = false
+            state.statusMessage = ""
+            currentProgress = nil
+        }
+
+        let dataSource = QueryResultExportDataSource(
+            rowBuffer: rowBuffer,
+            databaseType: databaseType,
+            driver: driver
+        )
+
+        let progress = PluginExportProgress()
+        currentProgress = progress
+        progress.setTotalRows(totalRows)
+
+        let pendingUpdate = ProgressUpdateCoalescer()
+        progress.onUpdate = { [weak self] table, index, rows, total, status in
+            let shouldDispatch = pendingUpdate.markPending()
+            if shouldDispatch {
+                Task { @MainActor [weak self] in
+                    pendingUpdate.clearPending()
+                    guard let self else { return }
+                    self.state.currentTable = table
+                    self.state.currentTableIndex = index
+                    self.state.processedRows = rows
+                    if total > 0 {
+                        self.state.progress = Double(rows) / Double(total)
+                    }
+                    if !status.isEmpty {
+                        self.state.statusMessage = status
+                    }
+                }
+            }
+        }
+
+        let exportTable = PluginExportTable(
+            name: config.fileName,
+            databaseName: "",
+            tableType: "query",
+            optionValues: plugin.defaultTableOptionValues()
+        )
+
+        do {
+            try await plugin.export(
+                tables: [exportTable],
+                dataSource: dataSource,
+                destination: url,
+                progress: progress
+            )
+        } catch {
+            try? FileManager.default.removeItem(at: url)
+            state.errorMessage = error.localizedDescription
+            throw error
+        }
+
+        let pluginWarnings = plugin.warnings
+        if !pluginWarnings.isEmpty {
+            state.warningMessage = pluginWarnings.joined(separator: "\n")
+        }
+
+        state.progress = 1.0
+    }
+
     // MARK: - Row Count Fetching
 
-    private func fetchTotalRowCount(for tables: [ExportTableItem]) async -> Int {
+    private func fetchTotalRowCount(for tables: [ExportTableItem], driver: DatabaseDriver) async -> Int {
         guard !tables.isEmpty else { return 0 }
 
         var total = 0

TablePro/Core/Services/Infrastructure/AppNotifications.swift

@@ -24,6 +24,10 @@ extension Notification.Name {
 
     static let licenseStatusDidChange = Notification.Name("licenseStatusDidChange")
 
+    // MARK: - Export
+
+    static let exportQueryResults = Notification.Name("exportQueryResults")
+
     // MARK: - SQL Favorites
 
     static let sqlFavoritesDidUpdate = Notification.Name("sqlFavoritesDidUpdate")

TablePro/Models/Export/ExportModels.swift

@@ -6,6 +6,14 @@
 import Foundation
 import TableProPluginKit
 
+// MARK: - Export Mode
+
+/// Defines the export mode: either exporting database tables or in-memory query results.
+enum ExportMode {
+    case tables(connection: DatabaseConnection, preselectedTables: Set<String>)
+    case queryResults(connection: DatabaseConnection, rowBuffer: RowBuffer, suggestedFileName: String)
+}
+
 // MARK: - Export Configuration
 
 @MainActor