refactor: Extract services and child views from complex files

Major refactoring to improve code organization and maintainability:

Phase 1 - DataChange.swift (1,095 → 4 files):
- SQLStatementGenerator: SQL generation logic
- DataChangeUndoManager: Undo/redo stack management
- DataChangeModels: Pure data models
- DataChangeManager: Refactored change tracking

Phase 2 - FilterPanelView.swift (758 → 260 lines):
- FilterRowView: Single filter row component
- SQLPreviewSheet: SQL preview modal
- FilterSettingsPopover: Settings popover
- QuickSearchField: Quick search component

Phase 3 - DataGridView.swift (1,706 → 700 lines):
- KeyHandlingTableView: NSTableView subclass
- TableRowViewWithMenu: Row view with context menu
- CellTextField: Custom text field
- DataGridCellFactory: Cell creation factory

Phase 4 - HistoryListViewController.swift (1,325 → 550 lines):
- HistoryDataProvider: Data fetching/filtering
- HistoryRowView: Table cell view
- HistoryTableView: Custom NSTableView

Phase 5 - MainContentView.swift (2,365 → 2,113 lines):
- QueryExecutionService: Query execution logic
- RowOperationsManager: Row operations (add/delete/undo)
- MainStatusBarView: Status bar component
- QueryTabContentView/TableTabContentView: Tab content views

Author: datlechin

OpenTable/Core/ChangeTracking/DataChangeManager.swift

@@ -0,0 +1,90 @@
+//
+//  DataChangeModels.swift
+//  OpenTable
+//
+//  Pure data models for tracking data changes.
+//  No business logic - just structures for representing change state.
+//
+
+import Foundation
+
+/// Represents a type of data change
+enum ChangeType: Equatable {
+    case update
+    case insert
+    case delete
+}
+
+/// Represents a single cell change
+struct CellChange: Identifiable, Equatable {
+    let id: UUID
+    let rowIndex: Int
+    let columnIndex: Int
+    let columnName: String
+    let oldValue: String?
+    let newValue: String?
+
+    init(
+        rowIndex: Int,
+        columnIndex: Int,
+        columnName: String,
+        oldValue: String?,
+        newValue: String?
+    ) {
+        self.id = UUID()
+        self.rowIndex = rowIndex
+        self.columnIndex = columnIndex
+        self.columnName = columnName
+        self.oldValue = oldValue
+        self.newValue = newValue
+    }
+}
+
+/// Represents a row-level change
+struct RowChange: Identifiable, Equatable {
+    let id: UUID
+    var rowIndex: Int
+    let type: ChangeType
+    var cellChanges: [CellChange]
+    let originalRow: [String?]?
+
+    init(
+        rowIndex: Int,
+        type: ChangeType,
+        cellChanges: [CellChange] = [],
+        originalRow: [String?]? = nil
+    ) {
+        self.id = UUID()
+        self.rowIndex = rowIndex
+        self.type = type
+        self.cellChanges = cellChanges
+        self.originalRow = originalRow
+    }
+}
+
+/// Represents an action that can be undone
+enum UndoAction {
+    case cellEdit(
+        rowIndex: Int,
+        columnIndex: Int,
+        columnName: String,
+        previousValue: String?,
+        newValue: String?
+    )
+    case rowInsertion(rowIndex: Int)
+    case rowDeletion(rowIndex: Int, originalRow: [String?])
+    /// Batch deletion of multiple rows (for undo as a single action)
+    case batchRowDeletion(rows: [(rowIndex: Int, originalRow: [String?])])
+    /// Batch insertion undo - when user deletes multiple inserted rows at once
+    case batchRowInsertion(rowIndices: [Int], rowValues: [[String?]])
+}
+
+// Note: TabPendingChanges is defined in QueryTab.swift
+
+// MARK: - Array Extension
+
+extension Array {
+    subscript(safe index: Int) -> Element? {
+        indices.contains(index) ? self[index] : nil
+    }
+}

OpenTable/Core/ChangeTracking/DataChangeModels.swift

@@ -0,0 +1,83 @@
+//
+//  DataChangeUndoManager.swift
+//  OpenTable
+//
+//  Manages undo/redo stacks for data changes.
+//  Extracted from DataChangeManager to improve separation of concerns.
+//
+
+import Foundation
+
+/// Manages undo/redo stacks for data changes
+final class DataChangeUndoManager {
+    /// Undo stack for reversing changes (LIFO)
+    private var undoStack: [UndoAction] = []
+
+    /// Redo stack for re-applying undone changes (LIFO)
+    private var redoStack: [UndoAction] = []
+
+    // MARK: - Public API
+
+    /// Check if there are any undo actions available
+    var canUndo: Bool {
+        !undoStack.isEmpty
+    }
+
+    /// Check if there are any redo actions available
+    var canRedo: Bool {
+        !redoStack.isEmpty
+    }
+
+    /// Push an undo action onto the stack
+    /// Clears the redo stack since new changes invalidate redo history
+    func push(_ action: UndoAction) {
+        undoStack.append(action)
+        // Don't clear redo here - let caller decide when to clear
+    }
+
+    /// Pop the last undo action from the stack
+    func popUndo() -> UndoAction? {
+        undoStack.popLast()
+    }
+
+    /// Pop the last redo action from the stack
+    func popRedo() -> UndoAction? {
+        redoStack.popLast()
+    }
+
+    /// Move an action from undo to redo stack
+    func moveToRedo(_ action: UndoAction) {
+        redoStack.append(action)
+    }
+
+    /// Move an action from redo to undo stack
+    func moveToUndo(_ action: UndoAction) {
+        undoStack.append(action)
+    }
+
+    /// Clear the undo stack
+    func clearUndo() {
+        undoStack.removeAll()
+    }
+
+    /// Clear the redo stack (called when new changes are made)
+    func clearRedo() {
+        redoStack.removeAll()
+    }
+
+    /// Clear both stacks
+    func clearAll() {
+        undoStack.removeAll()
+        redoStack.removeAll()
+    }
+
+    /// Get the count of undo actions
+    var undoCount: Int {
+        undoStack.count
+    }
+
+    /// Get the count of redo actions
+    var redoCount: Int {
+        redoStack.count
+    }
+}