refactor(datagrid): display cache moves to coordinator keyed by Row.id

Author: datlechin

TablePro/Views/Main/Child/MainEditorContentView.swift

@@ -581,6 +581,7 @@ struct MainEditorContentView: View {
                 hiddenColumns: columnVisibilityManager.hiddenColumns
             ),
             sortedIDs: sortedIDsForTab(tab),
+            displayFormats: displayFormats(for: tab),
             delegate: dataTabDelegate,
             selectedRowIndices: Binding(
                 get: { selectionState.indices },
@@ -656,23 +657,21 @@ struct MainEditorContentView: View {
             )
         }
 
-        applyDisplayFormats(to: provider, tab: tab)
         return provider
     }
 
-    private func applyDisplayFormats(to provider: InMemoryRowProvider, tab: QueryTab) {
-        let columns = provider.columns
-        let columnTypes = provider.columnTypes
-        guard !columns.isEmpty else { return }
+    private func displayFormats(for tab: QueryTab) -> [ValueDisplayFormat?] {
+        let tableRows = coordinator.tableRowsStore.existingTableRows(for: tab.id)
+        let columns = tableRows?.columns ?? []
+        let columnTypes = tableRows?.columnTypes ?? []
+        guard !columns.isEmpty else { return [] }
 
         let settings = AppSettingsManager.shared.dataGrid
         let service = ValueDisplayFormatService.shared
 
-        // Auto-detect formats when the setting is enabled
         var detected: [ValueDisplayFormat?] = Array(repeating: nil, count: columns.count)
         if settings.enableSmartValueDetection {
             let sampleRows: [[String?]]? = {
-                let tableRows = coordinator.tableRowsStore.existingTableRows(for: tab.id)
                 let rows = tableRows?.rows.prefix(10).map(\.values) ?? []
                 return rows.isEmpty ? nil : Array(rows)
             }()
@@ -682,7 +681,6 @@ struct MainEditorContentView: View {
                 sampleValues: sampleRows
             )
 
-            // Update service's auto-detected formats
             var autoMap: [String: ValueDisplayFormat] = [:]
             for (i, format) in detected.enumerated() where i < columns.count {
                 if let format {
@@ -694,7 +692,6 @@ struct MainEditorContentView: View {
             service.clearAutoDetectedFormats(connectionId: connectionId, tableName: tab.tableContext.tableName)
         }
 
-        // Merge with stored overrides (override > detection > nil)
         let connId = connectionId
         let tblName = tab.tableContext.tableName
         var merged = detected
@@ -710,10 +707,7 @@ struct MainEditorContentView: View {
             }
         }
 
-        // Only set if there's at least one non-nil format
-        if merged.contains(where: { $0 != nil }) {
-            provider.updateDisplayFormats(merged)
-        }
+        return merged.contains(where: { $0 != nil }) ? merged : []
     }
 
     /// Returns the display order as a permutation of `RowID`, or nil when no sort applies.

TablePro/Views/Results/DataGridCoordinator.swift

@@ -21,6 +21,8 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
     var changeManager: AnyChangeManager
     var isEditable: Bool
     var sortedIDs: [RowID]?
+    private(set) var columnDisplayFormats: [ValueDisplayFormat?] = []
+    private var displayCache: [RowID: [String?]] = [:]
     weak var delegate: (any DataGridViewDelegate)?
     weak var activeFKPreviewPopover: NSPopover?
     var dropdownColumns: Set<Int>?
@@ -150,11 +152,11 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
                 // When smart detection is toggled off, clear display formats so they stop being applied
                 if prev.enableSmartValueDetection != settings.enableSmartValueDetection
                     && !settings.enableSmartValueDetection {
-                    self.rowProvider.updateDisplayFormats([])
+                    self.updateDisplayFormats([])
                 }
 
                 if dataChanged {
-                    self.rowProvider.invalidateDisplayCache()
+                    self.invalidateDisplayCache()
                     let visibleRect = tableView.visibleRect
                     let visibleRange = tableView.rows(in: visibleRect)
                     if visibleRange.length > 0 {
@@ -200,6 +202,8 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
         overlayEditor?.dismiss(commit: false)
         rowProvider = InMemoryRowProvider(rows: [], columns: [])
         rowVisualStateCache.removeAll()
+        displayCache.removeAll()
+        columnDisplayFormats = []
         cachedRowCount = 0
         cachedColumnCount = 0
         sortedIDs = nil
@@ -254,7 +258,7 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
 
     func applyFullReplace() {
         guard let tableView else { return }
-        rowProvider.invalidateDisplayCache()
+        displayCache.removeAll()
         rebuildVisualStateCache()
         updateCache()
         tableView.reloadData()
@@ -281,13 +285,90 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
         return displayIndex
     }
 
+    func displayValue(forID id: RowID, column: Int, rawValue: String?, columnType: ColumnType?) -> String? {
+        if let cachedRow = displayCache[id], column >= 0, column < cachedRow.count, let cached = cachedRow[column] {
+            return cached
+        }
+        let format = column >= 0 && column < columnDisplayFormats.count ? columnDisplayFormats[column] : nil
+        let formatted = CellDisplayFormatter.format(rawValue, columnType: columnType, displayFormat: format) ?? rawValue
+
+        var rowCache = displayCache[id] ?? []
+        let neededCount = max(column + 1, columnDisplayFormats.count)
+        if rowCache.count < neededCount {
+            rowCache.append(contentsOf: Array(repeating: nil, count: neededCount - rowCache.count))
+        }
+        if column >= 0, column < rowCache.count {
+            rowCache[column] = formatted
+        }
+        displayCache[id] = rowCache
+        return formatted
+    }
+
+    func invalidateDisplayCache() {
+        displayCache.removeAll()
+    }
+
+    func updateDisplayFormats(_ formats: [ValueDisplayFormat?]) {
+        columnDisplayFormats = formats
+        displayCache.removeAll()
+    }
+
+    func syncDisplayFormats(_ formats: [ValueDisplayFormat?]) {
+        guard formats != columnDisplayFormats else { return }
+        columnDisplayFormats = formats
+        displayCache.removeAll()
+    }
+
+    func preWarmDisplayCache(upTo rowCount: Int) {
+        let tableRows = tableRowsProvider()
+        let displayCount = sortedIDs?.count ?? tableRows.count
+        let count = min(rowCount, displayCount)
+        guard count > 0 else { return }
+        for displayIndex in 0..<count {
+            guard let row = displayRow(at: displayIndex) else { continue }
+            let id = row.id
+            guard displayCache[id] == nil else { continue }
+            let columnCount = tableRows.columns.count
+            var rowCache = [String?](repeating: nil, count: columnCount)
+            for col in 0..<min(row.values.count, columnCount) {
+                let columnType = col < tableRows.columnTypes.count ? tableRows.columnTypes[col] : nil
+                let format = col < columnDisplayFormats.count ? columnDisplayFormats[col] : nil
+                rowCache[col] = CellDisplayFormatter.format(
+                    row.values[col],
+                    columnType: columnType,
+                    displayFormat: format
+                ) ?? row.values[col]
+            }
+            displayCache[id] = rowCache
+        }
+    }
+
+    private func pruneDisplayCacheToAliveIDs() {
+        guard !displayCache.isEmpty else { return }
+        let tableRows = tableRowsProvider()
+        var aliveIDs = Set<RowID>()
+        aliveIDs.reserveCapacity(tableRows.count)
+        for row in tableRows.rows {
+            aliveIDs.insert(row.id)
+        }
+        displayCache = displayCache.filter { aliveIDs.contains($0.key) }
+    }
+
+    private func invalidateDisplayCache(forDisplayRow displayIndex: Int, column: Int) {
+        guard let row = displayRow(at: displayIndex) else { return }
+        guard var rowCache = displayCache[row.id], column >= 0, column < rowCache.count else { return }
+        rowCache[column] = nil
+        displayCache[row.id] = rowCache
+    }
+
     func applyDelta(_ delta: Delta) {
         switch delta {
         case .cellChanged(let row, let column):
             guard let tableView else { return }
             let tableColumn = DataGridView.tableColumnIndex(for: column)
             guard row >= 0, row < tableView.numberOfRows else { return }
             guard tableColumn >= 0, tableColumn < tableView.numberOfColumns else { return }
+            invalidateDisplayCache(forDisplayRow: row, column: column)
             tableView.reloadData(
                 forRowIndexes: IndexSet(integer: row),
                 columnIndexes: IndexSet(integer: tableColumn)
@@ -304,6 +385,7 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
                 if tableColumn >= 0, tableColumn < tableView.numberOfColumns {
                     colSet.insert(tableColumn)
                 }
+                invalidateDisplayCache(forDisplayRow: position.row, column: position.column)
             }
             guard !rowSet.isEmpty, !colSet.isEmpty else { return }
             tableView.reloadData(forRowIndexes: rowSet, columnIndexes: colSet)
@@ -314,9 +396,11 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
         case .rowsRemoved(let indices):
             guard !indices.isEmpty else { return }
             removeMissingIDsFromSortedIDs()
+            pruneDisplayCacheToAliveIDs()
             applyRemovedRows(indices)
         case .columnsReplaced, .fullReplace:
             sortedIDs = nil
+            displayCache.removeAll()
             applyFullReplace()
         }
     }
@@ -341,7 +425,7 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
     }
 
     func invalidateCachesForUndoRedo() {
-        rowProvider.invalidateDisplayCache()
+        displayCache.removeAll()
         rebuildVisualStateCache()
         updateCache()
     }

TablePro/Views/Results/DataGridView+RowActions.swift

@@ -33,12 +33,13 @@ extension TableViewCoordinator {
 
     func copyRows(at indices: Set<Int>) {
         let sortedIndices = indices.sorted()
-        let columnTypes = rowProvider.columnTypes
+        let tableRows = tableRowsProvider()
+        let columnTypes = tableRows.columnTypes
         var tsvRows: [String] = []
         var htmlRows: [[String]] = []
 
         for index in sortedIndices {
-            guard let values = rowProvider.rowValues(at: index) else { continue }
+            guard let values = displayRow(at: index)?.values else { continue }
             let formatted = formatRowValues(values: values, columnTypes: columnTypes)
             tsvRows.append(formatted.joined(separator: "\t"))
             htmlRows.append(formatted)
@@ -51,13 +52,14 @@ extension TableViewCoordinator {
 
     func copyRowsWithHeaders(at indices: Set<Int>) {
         let sortedIndices = indices.sorted()
-        let columnTypes = rowProvider.columnTypes
-        let columns = rowProvider.columns
+        let tableRows = tableRowsProvider()
+        let columnTypes = tableRows.columnTypes
+        let columns = tableRows.columns
         var tsvRows: [String] = [columns.joined(separator: "\t")]
         var htmlRows: [[String]] = []
 
         for index in sortedIndices {
-            guard let values = rowProvider.rowValues(at: index) else { continue }
+            guard let values = displayRow(at: index)?.values else { continue }
             let formatted = formatRowValues(values: values, columnTypes: columnTypes)
             tsvRows.append(formatted.joined(separator: "\t"))
             htmlRows.append(formatted)
@@ -82,15 +84,15 @@ extension TableViewCoordinator {
     }
 
     func copyCellValue(at rowIndex: Int, columnIndex: Int) {
-        guard columnIndex >= 0 && columnIndex < rowProvider.columns.count else { return }
+        let tableRows = tableRowsProvider()
+        guard columnIndex >= 0 && columnIndex < tableRows.columns.count else { return }
+        guard let row = displayRow(at: rowIndex), columnIndex < row.values.count else { return }
 
-        let value = rowProvider.value(atRow: rowIndex, column: columnIndex) ?? "NULL"
-        let columnTypes = rowProvider.columnTypes
+        let value = row.values[columnIndex] ?? "NULL"
+        let columnTypes = tableRows.columnTypes
         let columnType = columnTypes.indices.contains(columnIndex) ? columnTypes[columnIndex] : nil
 
-        // Use formatted value when a display format is active
-        let formats = rowProvider.columnDisplayFormats
-        if columnIndex < formats.count, let format = formats[columnIndex], format != .raw {
+        if columnIndex < columnDisplayFormats.count, let format = columnDisplayFormats[columnIndex], format != .raw {
             let formatted = ValueDisplayFormatService.applyFormat(value, format: format)
             ClipboardService.shared.writeText(formatted)
             return
@@ -102,41 +104,44 @@ extension TableViewCoordinator {
 
     func copyRowsAsInsert(at indices: Set<Int>) {
         guard let tableName, let databaseType else { return }
+        let tableRows = tableRowsProvider()
         let driver = resolveDriver()
         let converter = SQLRowToStatementConverter(
             tableName: tableName,
-            columns: rowProvider.columns,
+            columns: tableRows.columns,
             primaryKeyColumn: primaryKeyColumn,
             databaseType: databaseType,
             quoteIdentifier: driver?.quoteIdentifier,
             escapeStringLiteral: driver?.escapeStringLiteral
         )
-        let rows = indices.sorted().compactMap { rowProvider.rowValues(at: $0) }
+        let rows = indices.sorted().compactMap { displayRow(at: $0)?.values }
         guard !rows.isEmpty else { return }
         ClipboardService.shared.writeText(converter.generateInserts(rows: rows))
     }
 
     func copyRowsAsUpdate(at indices: Set<Int>) {
         guard let tableName, let databaseType else { return }
+        let tableRows = tableRowsProvider()
         let driver = resolveDriver()
         let converter = SQLRowToStatementConverter(
             tableName: tableName,
-            columns: rowProvider.columns,
+            columns: tableRows.columns,
             primaryKeyColumn: primaryKeyColumn,
             databaseType: databaseType,
             quoteIdentifier: driver?.quoteIdentifier,
             escapeStringLiteral: driver?.escapeStringLiteral
         )
-        let rows = indices.sorted().compactMap { rowProvider.rowValues(at: $0) }
+        let rows = indices.sorted().compactMap { displayRow(at: $0)?.values }
         guard !rows.isEmpty else { return }
         ClipboardService.shared.writeText(converter.generateUpdates(rows: rows))
     }
 
     func copyRowsAsJson(at indices: Set<Int>) {
-        let rows = indices.sorted().compactMap { rowProvider.rowValues(at: $0) }
+        let rows = indices.sorted().compactMap { displayRow(at: $0)?.values }
         guard !rows.isEmpty else { return }
-        let columnTypes = rowProvider.columnTypes
-        let converter = JsonRowConverter(columns: rowProvider.columns, columnTypes: columnTypes)
+        let tableRows = tableRowsProvider()
+        let columnTypes = tableRows.columnTypes
+        let converter = JsonRowConverter(columns: tableRows.columns, columnTypes: columnTypes)
         ClipboardService.shared.writeText(converter.generateJson(rows: rows))
     }
 
@@ -162,11 +167,12 @@ extension TableViewCoordinator {
         let item = NSPasteboardItem()
         item.setString(String(row), forType: Self.rowDragType)
 
-        if let values = rowProvider.rowValues(at: row) {
-            let formatted = formatRowValues(values: values, columnTypes: rowProvider.columnTypes)
+        if let values = displayRow(at: row)?.values {
+            let tableRows = tableRowsProvider()
+            let formatted = formatRowValues(values: values, columnTypes: tableRows.columnTypes)
             item.setString(formatted.joined(separator: "\t"), forType: .string)
             item.setString(
-                HtmlTableEncoder.encode(rows: [formatted], headers: rowProvider.columns),
+                HtmlTableEncoder.encode(rows: [formatted], headers: tableRows.columns),
                 forType: .html
             )
         }

TablePro/Views/Results/DataGridView+TypePicker.swift

@@ -17,7 +17,7 @@ extension TableViewCoordinator {
     ) {
         guard tableView.view(atColumn: column, row: row, makeIfNecessary: false) != nil else { return }
 
-        let currentValue = rowProvider.value(atRow: row, column: columnIndex) ?? ""
+        let currentValue = cellValue(at: row, column: columnIndex) ?? ""
         let dbType = databaseType ?? .mysql
 
         let cellRect = tableView.rect(ofRow: row).intersection(tableView.rect(ofColumn: column))