perf(datagrid): serve row count from cache to smooth scrolling

Author: xuhengyu

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Changed
+
+- Data grid now serves the row count from its existing cache instead of recomputing it on every layout pass, reducing CPU churn while scrolling large result sets.
+
 ### Fixed
 
 - Oracle connections no longer crash the app when the server sends a backend message the driver cannot decode; the query fails with a clear error and the connection reconnects. (#483)

TablePro/Views/Results/DataGridCoordinator.swift

@@ -713,7 +713,7 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
     // MARK: - NSTableViewDataSource
 
     func numberOfRows(in tableView: NSTableView) -> Int {
-        sortedIDs?.count ?? tableRowsProvider().count
+        sortedIDs?.count ?? cachedRowCount
     }
 }
 

TableProTests/Views/Results/TableViewCoordinatorRowCountCacheTests.swift

@@ -0,0 +1,128 @@
+//
+//  TableViewCoordinatorRowCountCacheTests.swift
+//  TableProTests
+//
+
+import SwiftUI
+import TableProPluginKit
+import Testing
+
+@testable import TablePro
+
+@Suite("TableViewCoordinator cachedRowCount sync")
+@MainActor
+struct TableViewCoordinatorRowCountCacheTests {
+    private func makeCoordinator(rows: ContiguousArray<Row>) -> TableViewCoordinator {
+        let coordinator = TableViewCoordinator(
+            changeManager: AnyChangeManager(DataChangeManager()),
+            isEditable: true,
+            selectedRowIndices: .constant([]),
+            delegate: nil,
+            layoutPersister: FakeRowCountPersister()
+        )
+        var captured = TableRows(rows: rows, columns: ["c"])
+        coordinator.tableRowsProvider = { captured }
+        coordinator.tableRowsMutator = { mutation in mutation(&captured) }
+        coordinator.updateCache()
+        return coordinator
+    }
+
+    @Test("cachedRowCount tracks provider after initial load")
+    func cacheMatchesProviderOnLoad() {
+        let rows: ContiguousArray<Row> = [
+            Row(id: .existing(0), values: [.text("a")]),
+            Row(id: .existing(1), values: [.text("b")]),
+            Row(id: .existing(2), values: [.text("c")]),
+        ]
+        let coordinator = makeCoordinator(rows: rows)
+
+        #expect(coordinator.cachedRowCount == 3)
+        #expect(coordinator.cachedRowCount == coordinator.tableRowsProvider().count)
+    }
+
+    @Test("updateCache picks up appended rows")
+    func updateCacheReflectsAppendedRows() {
+        let coordinator = makeCoordinator(rows: [])
+
+        coordinator.tableRowsMutator { rows in
+            _ = rows.appendInsertedRow(values: [.text("a")])
+            _ = rows.appendInsertedRow(values: [.text("b")])
+        }
+        coordinator.updateCache()
+
+        #expect(coordinator.cachedRowCount == 2)
+        #expect(coordinator.cachedRowCount == coordinator.tableRowsProvider().count)
+    }
+
+    @Test("updateCache picks up removed rows")
+    func updateCacheReflectsRemovedRows() {
+        let rows: ContiguousArray<Row> = [
+            Row(id: .existing(0), values: [.text("a")]),
+            Row(id: .existing(1), values: [.text("b")]),
+            Row(id: .existing(2), values: [.text("c")]),
+        ]
+        let coordinator = makeCoordinator(rows: rows)
+
+        coordinator.tableRowsMutator { rows in
+            _ = rows.remove(rowIDs: [.existing(1)])
+        }
+        coordinator.updateCache()
+
+        #expect(coordinator.cachedRowCount == 2)
+        #expect(coordinator.cachedRowCount == coordinator.tableRowsProvider().count)
+    }
+
+    @Test("updateCache reflects full replace")
+    func updateCacheReflectsFullReplace() {
+        let rows: ContiguousArray<Row> = [
+            Row(id: .existing(0), values: [.text("a")]),
+        ]
+        let coordinator = makeCoordinator(rows: rows)
+
+        coordinator.tableRowsMutator { rows in
+            _ = rows.replace(rows: [[.text("x")], [.text("y")], [.text("z")], [.text("w")]])
+        }
+        coordinator.updateCache()
+
+        #expect(coordinator.cachedRowCount == 4)
+        #expect(coordinator.cachedRowCount == coordinator.tableRowsProvider().count)
+    }
+
+    @Test("sortedIDs count takes precedence over cachedRowCount fallback")
+    func sortedIDsCountPrecedesCache() {
+        let rows: ContiguousArray<Row> = [
+            Row(id: .existing(0), values: [.text("a")]),
+            Row(id: .existing(1), values: [.text("b")]),
+            Row(id: .existing(2), values: [.text("c")]),
+        ]
+        let coordinator = makeCoordinator(rows: rows)
+
+        coordinator.sortedIDs = [.existing(2), .existing(0)]
+        coordinator.updateCache()
+
+        #expect(coordinator.cachedRowCount == 2)
+    }
+
+    @Test("releaseData zeroes cachedRowCount")
+    func releaseDataZeroesCache() {
+        let rows: ContiguousArray<Row> = [
+            Row(id: .existing(0), values: [.text("a")]),
+            Row(id: .existing(1), values: [.text("b")]),
+        ]
+        let coordinator = makeCoordinator(rows: rows)
+        #expect(coordinator.cachedRowCount == 2)
+
+        coordinator.releaseData()
+
+        #expect(coordinator.cachedRowCount == 0)
+    }
+}
+
+@MainActor
+private final class FakeRowCountPersister: ColumnLayoutPersisting {
+    func load(for tableName: String, connectionId: UUID) -> ColumnLayoutState? { nil }
+
+    func save(_ layout: ColumnLayoutState, for tableName: String, connectionId: UUID) {}
+
+    func clear(for tableName: String, connectionId: UUID) {}
+}