perf(editor): avoid O(n) Unicode comparison of query text during SwiftUI diffs

Author: datlechin

TablePro/Models/Query/QueryTabState.swift

@@ -288,6 +288,29 @@ struct TabQueryContent: Equatable {
         if queryNS.length != savedNS.length { return true }
         return queryNS != savedNS
     }
+
+    static func == (lhs: TabQueryContent, rhs: TabQueryContent) -> Bool {
+        // `query` can be multiple megabytes and is bridged from the editor's NSTextStorage. The synthesized `==`
+        // compared it with Swift's canonical Unicode equality, which walks the whole string through NFC normalization
+        // on every SwiftUI diff and pins the CPU while editing a large query. NSString equality returns in O(1) when
+        // the lengths differ (every keystroke changes the length) and uses literal comparison otherwise.
+        guard (lhs.query as NSString).isEqual(to: rhs.query),
+              lhs.queryParameters == rhs.queryParameters,
+              lhs.isParameterPanelVisible == rhs.isParameterPanelVisible,
+              lhs.sourceFileURL == rhs.sourceFileURL,
+              lhs.loadMtime == rhs.loadMtime,
+              lhs.externalModificationDetected == rhs.externalModificationDetected else {
+            return false
+        }
+        switch (lhs.savedFileContent, rhs.savedFileContent) {
+        case (nil, nil):
+            return true
+        case let (lhsSaved?, rhsSaved?):
+            return (lhsSaved as NSString).isEqual(to: rhsSaved)
+        default:
+            return false
+        }
+    }
 }
 
 struct TabDisplayState: Equatable {

TableProTests/Models/Query/TabQueryContentEqualityTests.swift

@@ -0,0 +1,62 @@
+import Foundation
+@testable import TablePro
+import Testing
+
+@Suite("TabQueryContent.Equatable")
+struct TabQueryContentEqualityTests {
+    @Test("Equal when all fields match")
+    func equalWhenIdentical() {
+        let a = TabQueryContent(query: "SELECT * FROM users;")
+        let b = TabQueryContent(query: "SELECT * FROM users;")
+        #expect(a == b)
+    }
+
+    @Test("Not equal when the query changes length")
+    func notEqualOnLengthChange() {
+        var a = TabQueryContent(query: "SELECT 1")
+        let b = TabQueryContent(query: "SELECT 12")
+        #expect(a != b)
+        a.query = "SELECT 12"
+        #expect(a == b)
+    }
+
+    @Test("Not equal when the query changes at the same length")
+    func notEqualOnSameLengthChange() {
+        let a = TabQueryContent(query: "abc")
+        let b = TabQueryContent(query: "abd")
+        #expect(a != b)
+    }
+
+    @Test("Detects a single-character edit in a large query")
+    func detectsEditInLargeQuery() {
+        let base = String(repeating: "SELECT 1;\n", count: 100_000)
+        let a = TabQueryContent(query: base)
+        let b = TabQueryContent(query: base + "X")
+        #expect(a != b)
+        let c = TabQueryContent(query: base)
+        #expect(a == c)
+    }
+
+    @Test("Not equal when a non-text field differs")
+    func notEqualOnOtherField() {
+        var a = TabQueryContent(query: "Q")
+        let b = TabQueryContent(query: "Q")
+        a.isParameterPanelVisible = true
+        #expect(a != b)
+        a.isParameterPanelVisible = false
+        #expect(a == b)
+    }
+
+    @Test("savedFileContent participates in equality")
+    func savedFileContentEquality() {
+        var a = TabQueryContent(query: "Q")
+        var b = TabQueryContent(query: "Q")
+        #expect(a == b)
+        a.savedFileContent = "disk"
+        #expect(a != b)
+        b.savedFileContent = "disk"
+        #expect(a == b)
+        b.savedFileContent = "other"
+        #expect(a != b)
+    }
+}