@@ -59,29 +59,9 @@ final class QueryViewModel {
5959 var columns: [String] = []
6060 var columnOrder: [String] = []
6161 var hiddenColumns: Set<String> = []
62− /// The full persisted set of hidden columns for the current stream, including
63− /// ones absent from the current result. Hiding a column drops it from the
64− /// SELECT list, so it's missing from the very next result and `hiddenColumns`
65− /// (only the columns present) forgets it — the next save would then erase the
66− /// preference. This keeps the intent, mirroring LiveTailViewModel.
67− private(set) var savedHiddenColumns: Set<String> = []
68− /// The persisted column order including columns absent from the current
69− /// result (the order counterpart of `savedHiddenColumns`), so saving doesn't
70− /// drop a hidden column's position and it returns to its place when shown.
71− private var savedColumnOrder: [String] = []
7262 var autoHiddenColumns: Set<String> = []
7363 /// Column config from a saved query, applied on next query execution.
7464 var pendingColumnConfig: ColumnConfiguration?
75−
76− /// The connection and stream the editor text and results belong to. The view
77− /// model outlives QueryView (switching tabs keeps the query), so the view
78− /// compares this on appear to catch a stream/server change made while another
79− /// tab was showing.
80− struct BoundContext: Equatable {
81− let connectionID: UUID?
82− let stream: String
83− }
84− var boundContext: BoundContext?
8565 private var currentStream: String?
8666 var isLoading = false
8767 var errorMessage: String?
@@ -212,16 +192,9 @@ final class QueryViewModel {
212192 return columnOrder.filter { !allHidden.contains($0) }
213193 }
214194
215− /// Whether any column is hidden — including saved-hidden columns that aren't
216− /// in the current result, which "Show All" can bring back.
217− var hasHiddenColumns: Bool {
218− !hiddenColumns.isEmpty || !autoHiddenColumns.isEmpty || !savedHiddenColumns.isEmpty
219− }
220−
221195 func toggleColumnVisibility(_ column: String) {
222196 if hiddenColumns.contains(column) {
223197 hiddenColumns.remove(column)
224− savedHiddenColumns.remove(column)
225198 } else if autoHiddenColumns.contains(column) {
226199 autoHiddenColumns.remove(column)
227200 } else {
@@ -230,7 +203,6 @@ final class QueryViewModel {
230203 let visibleCount = columnOrder.count - allHidden.count
231204 if visibleCount > 1 {
232205 hiddenColumns.insert(column)
233− savedHiddenColumns.insert(column)
234206 }
235207 }
236208 saveColumnConfig()
@@ -239,7 +211,6 @@ final class QueryViewModel {
239211
240212 func showAllColumns() {
241213 hiddenColumns.removeAll()
242− savedHiddenColumns.removeAll()
243214 autoHiddenColumns.removeAll()
244215 saveColumnConfig()
245216 updateSQLColumns()
@@ -269,116 +240,32 @@ final class QueryViewModel {
269240
270241 func resetColumnConfig() {
271242 columnOrder = columns
272− savedColumnOrder = []
273243 hiddenColumns.removeAll()
274− savedHiddenColumns.removeAll()
275244 autoHiddenColumns.removeAll()
276245 saveColumnConfig()
277246 updateSQLColumns()
278247 }
279248
280− /// Rewrites the SELECT clause of `sqlQuery` to reflect the user's column
281− /// choices (order and hidden columns; auto-hidden columns stay display-only).
249+ /// Rewrites the SELECT clause of `sqlQuery` to reflect the current `visibleColumns`.
282250 func updateSQLColumns() {
283− guard let range = SQLTokenizer.selectColumnListRange(in: sqlQuery),
284− let currentList = Self.parseColumnList(sqlQuery[range]) else { return }
285−
286− // Project the user's choices only. `autoHiddenColumns` is a display
287− // heuristic for the current rows (the field is empty in all of them);
288− // baking it into the SQL would stop the field from ever being fetched
289− // again, even for a time range where it has values.
290− let visible = columnOrder.filter { !hiddenColumns.contains($0) }
291− guard !visible.isEmpty else { return }
251+ guard let range = SQLTokenizer.selectColumnListRange(in: sqlQuery) else { return }
292252
293− // Columns an explicit list names that aren't in the results: Parseable
294− // omits all-null fields from query JSON, so a sparse listed field can be
295− // missing from `columns`. Keep it (unless the user hid it) rather than
296− // silently dropping it from the SELECT on the next rewrite.
297− var listedButAbsent: [String] = []
298− var excludesHiddenColumn = false
299− if case .identifiers(let names) = currentList {
300− let present = Set(columns)
301− listedButAbsent = names.filter { !present.contains($0) && !savedHiddenColumns.contains($0) }
302− // A column the user hid is absent from these results precisely
303− // because this list was narrowed to exclude it.
304− excludesHiddenColumn = !savedHiddenColumns.isSubset(of: present)
305− }
253+ let visible = visibleColumns
254+ guard !visible.isEmpty else { return }
306255
307256 let newColumnList: String
308257 // Use `*` whenever every column is visible, regardless of display order —
309258 // reordering columns (a set-preserving permutation) must not pin the query
310− // to an explicit snapshot that hides newly-appearing fields on re-query —
311− // unless the list is explicit because it leaves out a hidden column, which
312− // `*` would fetch again.
313− if !excludesHiddenColumn && visible.count == columns.count && Set(visible) == Set(columns) {
259+ // to an explicit snapshot that hides newly-appearing fields on re-query.
260+ if visible.count == columns.count && Set(visible) == Set(columns) {
314261 newColumnList = "*"
315262 } else {
316− newColumnList = (visible + listedButAbsent).map { Self.escapeSQLIdentifier($0) }.joined(separator: ", ")
263+ newColumnList = visible.map { Self.escapeSQLIdentifier($0) }.joined(separator: ", ")
317264 }
318265
319266 sqlQuery.replaceSubrange(range, with: newColumnList)
320267 }
321268
322− enum ColumnListShape: Equatable {
323− case star
324− /// Plain column references, as the column names they resolve to.
325− case identifiers([String])
326− }
327−
328− /// Parses a SELECT list the column manager can regenerate without changing
329− /// what the query computes: `*`, or a comma-separated list of plain column
330− /// references. Anything else — aggregates, expressions, aliases
331− /// (`count(*) AS n`), qualified names — returns nil: rewriting it with `*` or
332− /// bare result keys would break the query, so the column manager then only
333− /// hides/reorders client-side.
334− nonisolated static func parseColumnList(_ list: Substring) -> ColumnListShape? {
335− let tokens = SQLTokenizer.tokenize(String(list)).filter { !$0.kind.isTrivia }
336− if tokens.count == 1, tokens[0].kind == .star { return .star }
337− guard tokens.count % 2 == 1 else { return nil }
338− var names: [String] = []
339− for (index, token) in tokens.enumerated() {
340− if index % 2 == 1 {
341− guard token.kind == .comma else { return nil }
342− continue
343− }
344− switch token.kind {
345− // DataFusion folds unquoted identifiers to lowercase.
346− case .identifier(let name): names.append(name.lowercased())
347− case .quotedIdentifier(let name): names.append(name)
348− default: return nil
349− }
350− }
351− return .identifiers(names)
352− }
353−
354− /// Inserts `newColumns` into `order`, placing each one that appears in
355− /// `reference` (a saved order) right after its nearest saved predecessor
356− /// that's already placed — or first if none is — and appending the rest.
357− /// Used to keep the positions of columns that are absent for a while.
358− nonisolated static func mergedColumnOrder(
359− _ order: [String], inserting newColumns: [String], reference: [String]
360− ) -> [String] {
361− var result = order
362− let referenceIndex = Dictionary(reference.enumerated().map { ($1, $0) }, uniquingKeysWith: { first, _ in first })
363− let pending = newColumns.filter { referenceIndex[$0] == nil }
364− let positioned = newColumns
365− .filter { referenceIndex[$0] != nil }
366− .sorted { referenceIndex[$0]! < referenceIndex[$1]! }
367− for column in positioned where !result.contains(column) {
368− let savedIndex = referenceIndex[column]!
369− let predecessor = reference[..<savedIndex].reversed().first { result.contains($0) }
370− if let predecessor, let position = result.firstIndex(of: predecessor) {
371− result.insert(column, at: position + 1)
372− } else {
373− result.insert(column, at: 0)
374− }
375− }
376− for column in pending where !result.contains(column) {
377− result.append(column)
378− }
379− return result
380− }
381−
382269 // MARK: - Column Configuration Persistence
383270
384271 struct ColumnConfiguration: Codable {
@@ -392,16 +279,7 @@ final class QueryViewModel {
392279
393280 private func saveColumnConfig() {
394281 guard let stream = currentStream else { return }
395− // Persist the full intended hidden set and order, not just the currently
396− // present columns (see `savedHiddenColumns` / `savedColumnOrder`).
397− let present = Set(columnOrder)
398− let order = Self.mergedColumnOrder(
399− columnOrder,
400− inserting: savedColumnOrder.filter { !present.contains($0) },
401− reference: savedColumnOrder
402− )
403− savedColumnOrder = order
404− let config = ColumnConfiguration(order: order, hidden: savedHiddenColumns.union(hiddenColumns))
282+ let config = ColumnConfiguration(order: columnOrder, hidden: hiddenColumns)
405283 if let data = try? JSONEncoder().encode(config) {
406284 UserDefaults.standard.set(data, forKey: Self.columnConfigKey(for: stream))
407285 }
@@ -430,9 +308,7 @@ final class QueryViewModel {
430308
431309 guard let config else {
432310 columnOrder = extractedColumns
433− savedColumnOrder = []
434311 hiddenColumns = []
435− savedHiddenColumns = []
436312 return
437313 }
438314
@@ -445,8 +321,6 @@ final class QueryViewModel {
445321 merged.append(col)
446322 }
447323 columnOrder = merged
448− savedColumnOrder = config.order
449− savedHiddenColumns = config.hidden
450324 hiddenColumns = config.hidden.intersection(extractedSet)
451325
452326 // The `visibleCount > 1` guard in toggleColumnVisibility only covers
@@ -645,8 +519,6 @@ final class QueryViewModel {
645519 // report stale column names after the failure.
646520 columnOrder = []
647521 hiddenColumns = []
648− savedHiddenColumns = []
649− savedColumnOrder = []
650522 autoHiddenColumns = []
651523 }
652524 }
@@ -813,8 +685,6 @@ final class QueryViewModel {
813685 columns = []
814686 columnOrder = []
815687 hiddenColumns = []
816− savedHiddenColumns = []
817− savedColumnOrder = []
818688 autoHiddenColumns = []
819689 currentStream = nil
820690 resultCount = 0
@@ -828,7 +698,6 @@ final class QueryViewModel {
828698 // a later reload guard never sees a non-nil stream paired with empty data.
829699 latestSchemaStream = nil
830700 latestQueryStream = nil
831− boundContext = nil
832701 }
833702
834703 /// Modifies `sqlQuery` to add a column-value filter condition.
@@ -838,139 +707,75 @@ final class QueryViewModel {
838707 let condition: String
839708 if let value, value != .null {
840709 let literal = value.sqlLiteral
841− // Exclude with `IS DISTINCT FROM`, not `<>`: under SQL's three-valued
842− // logic `NULL <> 'x'` is NULL, so `<>` also dropped every row where the
843− // column is missing/NULL — common for sparse fields — which "exclude
844− // this value" doesn't ask for (the live-tail exclude keeps them too).
845− condition = exclude
846− ? "\(escapedCol) IS DISTINCT FROM \(literal)"
847− : "\(escapedCol) = \(literal)"
710+ condition = exclude ? "\(escapedCol) <> \(literal)" : "\(escapedCol) = \(literal)"
848711 } else {
849712 condition = exclude ? "\(escapedCol) IS NOT NULL" : "\(escapedCol) IS NULL"
850713 }
851714
852− let sql = sqlQuery.trimmingCharacters(in: .whitespacesAndNewlines)
715+ var sql = sqlQuery.trimmingCharacters(in: .whitespacesAndNewlines)
853716 if sql.isEmpty { return }
854717
855718 // Locate the top-level WHERE and the first trailing clause using the
856719 // tokenizer rather than a raw regex, so keywords inside quoted
857720 // identifiers, string literals, comments, or subqueries are ignored.
858− let tokens = SQLTokenizer.tokenize(sql)
721+ let tailKeywords: Set<String> = ["ORDER", "GROUP", "HAVING", "LIMIT", "OFFSET"]
859722 var depth = 0
860− // WHERE and the trailing clauses only follow the top-level FROM. Keywords
861− // before it belong to the SELECT list — e.g. a field named `offset` or
862− // `limit` (which the tokenizer reports as keywords) — and must not be
863− // mistaken for clause starts.
864− var fromSeen = false
865− var whereIndex: Int?
866− var tailIndex: Int?
723+ var whereEnd: String.Index?
724+ var tailStart: String.Index?
867725 // Track whether the existing WHERE body has a top-level OR — only then does
868726 // AND-ing a new condition need parentheses to preserve precedence.
869727 var bodyHasTopLevelOr = false
870− // The last token that is actual SQL — not whitespace, a comment, or a
871− // statement-terminating `;`. New text is spliced in right after such
872− // tokens (never at the raw end of the string), so a trailing `;` or a
873− // trailing `-- comment` stays at the end instead of swallowing the
874− // appended condition: `... LIMIT 10;` must not become `... LIMIT 10; WHERE`,
875− // and `... -- note` must not become `... -- note WHERE <commented out>`.
876− func isSignificant(_ token: SQLTokenizer.Token) -> Bool {
877− !token.kind.isTrivia && token.kind != .other(";")
878− }
879− func nextSignificantKind(after index: Int) -> SQLTokenizer.TokenKind? {
880− tokens[(index + 1)...].first(where: { isSignificant($0) })?.kind
881− }
882− // Whether the keyword at `index` actually opens a trailing clause. ORDER and
883− // GROUP must be followed by BY (so `WITHIN GROUP (…)` or a column named
884− // `order` doesn't count), and LIMIT/OFFSET by their row count (so a column
885− // named `offset` in `WHERE offset > 5` doesn't cut the WHERE body short).
886− func startsTrailingClause(_ keyword: String, at index: Int) -> Bool {
887− switch keyword {
888− case "ORDER", "GROUP":
889− return nextSignificantKind(after: index) == .keyword("BY")
890− case "LIMIT", "OFFSET":
891− if case .number = nextSignificantKind(after: index) { return true }
892− return false
893− case "HAVING":
894− return true
895− default:
896− return false
897− }
898− }
899− var lastSignificant: Int?
900− for (idx, token) in tokens.enumerated() {
901− if isSignificant(token) { lastSignificant = idx }
728+ for token in SQLTokenizer.tokenize(sql) {
902729 switch token.kind {
903730 case .leftParen:
904731 depth += 1
905732 case .rightParen:
906733 depth = max(0, depth - 1)
907− case .keyword("FROM") where depth == 0:
908− fromSeen = true
909− case .keyword(let kw) where depth == 0 && fromSeen:
910− if kw == "WHERE", whereIndex == nil {
911− whereIndex = idx
912− // A trailing clause seen *before* the WHERE (e.g. the GROUP BY of
913− // the first SELECT in `... GROUP BY a UNION ALL SELECT ... WHERE`)
914− // doesn't end this WHERE's body. Keeping it would make the body
915− // range run backwards (a trapping `Range`), so look for the
916− // body's end afresh after the WHERE.
917− tailIndex = nil
918− } else if tailIndex == nil, startsTrailingClause(kw, at: idx) {
919− tailIndex = idx
920− } else if kw == "OR", whereIndex != nil, tailIndex == nil {
734+ case .keyword(let kw) where depth == 0:
735+ if kw == "WHERE", whereEnd == nil {
736+ whereEnd = token.range.upperBound
737+ } else if tailKeywords.contains(kw), tailStart == nil {
738+ tailStart = token.range.lowerBound
739+ } else if kw == "OR", whereEnd != nil, tailStart == nil {
921740 bodyHasTopLevelOr = true
922741 }
923742 default:
924743 break
925744 }
926745 }
927− // Nothing but comments/semicolons — there's no statement to filter.
928− guard let lastSignificant else { return }
929−
930− // Each branch rebuilds the query from slices of the original text, keeping
931− // the user's line breaks: joining pieces with single spaces would pull the
932− // text after a `-- comment` onto the comment's line and comment it out.
933− // Text spliced directly in front of another token (`(a = 1)ORDER BY`) needs
934− // a space so the two don't fuse (`... IS NULLORDER BY`).
935− func separated(_ rest: Substring) -> String {
936− guard let next = rest.first, !next.isWhitespace, next != ";" else { return String(rest) }
937− return " " + rest
938− }
939− if let whereIndex {
940− // The WHERE body runs up to the first trailing clause, or to the end
941− // of the statement. Only its significant tokens bound the splice, so a
942− // comment between the body and ORDER BY stays after the new condition.
943− let bodyEndIndex = tailIndex ?? (lastSignificant + 1)
944− let bodyIndices = (whereIndex + 1)..<bodyEndIndex
945− if let first = bodyIndices.first(where: { isSignificant(tokens[$0]) }),
946− let last = bodyIndices.last(where: { isSignificant(tokens[$0]) }) {
947− // Parenthesize the existing WHERE body before AND-ing the new
948− // condition only when it has a top-level OR, otherwise the OR
949− // silently changes meaning: `WHERE a = 1 OR b = 2` would become
950− // `WHERE a = 1 OR b = 2 AND c = 3`, which SQL binds as
951− // `a = 1 OR (b = 2 AND c = 3)` rather than the intended
952− // `(a = 1 OR b = 2) AND c = 3`. A body without a top-level OR is
953− // left un-parenthesized so simple filters stay readable.
954− let bodyStart = tokens[first].range.lowerBound
955− let bodyEnd = tokens[last].range.upperBound
956− let body = sql[bodyStart..<bodyEnd]
957− let wrappedBody = bodyHasTopLevelOr ? "(\(body))" : String(body)
958− sqlQuery = "\(sql[..<bodyStart])\(wrappedBody) AND \(condition)\(separated(sql[bodyEnd...]))"
746+
747+ if let whereEnd {
748+ // Parenthesize the existing WHERE body before AND-ing the new
749+ // condition only when it has a top-level OR, otherwise the OR
750+ // silently changes meaning: `WHERE a = 1 OR b = 2` would become
751+ // `WHERE a = 1 OR b = 2 AND c = 3`, which SQL binds as
752+ // `a = 1 OR (b = 2 AND c = 3)` rather than the intended
753+ // `(a = 1 OR b = 2) AND c = 3`. A body without a top-level OR is
754+ // left un-parenthesized so simple filters stay readable.
755+ let bodyEnd = tailStart ?? sql.endIndex
756+ let head = sql[..<whereEnd]
757+ let body = sql[whereEnd..<bodyEnd].trimmingCharacters(in: .whitespacesAndNewlines)
758+ let tail = sql[bodyEnd...].trimmingCharacters(in: .whitespacesAndNewlines)
759+ // An empty WHERE body (e.g. a half-written `... WHERE` with no
760+ // condition yet, or `WHERE` immediately followed by ORDER/GROUP/
761+ // LIMIT) would otherwise produce `WHERE AND <condition>` — a
762+ // dangling AND with no left operand. Drop the AND in that case.
763+ if body.isEmpty {
764+ sql = "\(head) \(condition)"
959765 } else {
960− // An empty WHERE body (e.g. a half-written `... WHERE` with no
961− // condition yet, or `WHERE` immediately followed by ORDER/GROUP/
962− // LIMIT) would otherwise produce `WHERE AND <condition>` — a
963− // dangling AND with no left operand. Drop the AND in that case.
964− let whereEnd = tokens[whereIndex].range.upperBound
965− sqlQuery = "\(sql[..<whereEnd]) \(condition)\(separated(sql[whereEnd...]))"
766+ let wrappedBody = bodyHasTopLevelOr ? "(\(body))" : body
767+ sql = "\(head) \(wrappedBody) AND \(condition)"
966768 }
967− } else if let tailIndex {
968− let tailStart = tokens[tailIndex].range.lowerBound
969− sqlQuery = "\(sql[..<tailStart])WHERE \(condition) \(sql[tailStart...])"
769+ if !tail.isEmpty {
770+ sql += " \(tail)"
771+ }
772+ } else if let tailStart {
773+ sql.insert(contentsOf: "WHERE \(condition) ", at: tailStart)
970774 } else {
971− let statementEnd = tokens[lastSignificant].range.upperBound
972− sqlQuery = "\(sql[..<statementEnd]) WHERE \(condition)\(separated(sql[statementEnd...]))"
775+ sql += " WHERE \(condition)"
973776 }
777+
778+ sqlQuery = sql
974779 }
975780
976781 /// Sets the default query for the given stream, returning `true` if the
@@ -1014,10 +819,6 @@ final class QueryViewModel {
1014819 // MARK: - Query History
1015820
1016821 private func addToHistory(_ entry: QueryHistoryEntry) {
1017− // Start from what's persisted, not this instance's copy: a model created
1018− // earlier (e.g. one whose query finished after a reconnect replaced it)
1019− // would otherwise overwrite newer entries saved by the current one.
1020− queryHistory = Self.loadHistory()
1021822 // Deduplicate consecutive identical queries
1022823 if queryHistory.first?.sql == entry.sql { return }
1023824 queryHistory.insert(entry, at: 0)