Skip to content

A native macOS / windows / Linux database IDE built with Swift and AppKit. Connect to PostgreSQL, MySQL, SQLite, and Redis from a single app with a fast, keyboard-driven interface.

C++

feat(redis): add namespace tree primitives

Tobid7d7ca3b15c9
diff --git a/macos/Data/Adapters/Redis/RedisModels.swift b/macos/Data/Adapters/Redis/RedisModels.swift
index b08dea8..fecb4da 100644
--- a/macos/Data/Adapters/Redis/RedisModels.swift
+++ b/macos/Data/Adapters/Redis/RedisModels.swift
@@ -37,3 +37,38 @@ struct RedisSlowLogEntry: Identifiable, Sendable {
let command: String
let clientInfo: String
}
+
+struct RedisKeyScanResult: Sendable, Equatable {
+ let keys: [String]
+ let isTruncated: Bool
+}
+
+struct RedisKeyScanAccumulator {
+ private(set) var uniqueKeys: Set<String> = []
+ private let maximumCount: Int
+ private var discardedUniqueKey = false
+
+ init(maximumCount: Int) {
+ precondition(maximumCount > 0)
+ self.maximumCount = maximumCount
+ }
+
+ var isFull: Bool { uniqueKeys.count >= maximumCount }
+
+ mutating func append(_ keys: [String]) {
+ for key in keys where !uniqueKeys.contains(key) {
+ if uniqueKeys.count < maximumCount {
+ uniqueKeys.insert(key)
+ } else {
+ discardedUniqueKey = true
+ }
+ }
+ }
+
+ func result(hasMoreCursor: Bool) -> RedisKeyScanResult {
+ RedisKeyScanResult(
+ keys: uniqueKeys.sorted(),
+ isTruncated: hasMoreCursor || discardedUniqueKey
+ )
+ }
+}
diff --git a/macos/Presentation/Views/Redis/RedisKeyNamespaceTree.swift b/macos/Presentation/Views/Redis/RedisKeyNamespaceTree.swift
new file mode 100644
index 0000000..6906173
--- /dev/null
+++ b/macos/Presentation/Views/Redis/RedisKeyNamespaceTree.swift
@@ -0,0 +1,76 @@
+// RedisKeyNamespaceTree.swift
+// Gridex
+//
+// Pure namespace tree construction for Redis key names.
+
+import Foundation
+
+struct RedisKeyNamespaceNode: Identifiable, Equatable {
+ let id: String
+ let segment: String
+ let concreteKey: String?
+ let children: [RedisKeyNamespaceNode]
+ let descendantKeyCount: Int
+}
+
+enum RedisKeyNamespaceTree {
+
+ static func build(keys: [String], delimiter: String) -> [RedisKeyNamespaceNode] {
+ precondition(!delimiter.isEmpty)
+
+ var roots: [String: TrieNode] = [:]
+ for key in Set(keys) {
+ let segments = key.components(separatedBy: delimiter)
+ let rootSegment = segments[0]
+ let root = roots[rootSegment] ?? TrieNode(segment: rootSegment)
+ roots[rootSegment] = root
+
+ var current = root
+ for segment in segments.dropFirst() {
+ let child = current.children[segment] ?? TrieNode(segment: segment)
+ current.children[segment] = child
+ current = child
+ }
+ current.concreteKey = key
+ }
+
+ return roots.values
+ .sorted { $0.segment < $1.segment }
+ .map { materialize($0, path: [$0.segment]) }
+ }
+
+ static func displayLabel(for segment: String) -> String {
+ segment.isEmpty ? "(empty)" : segment
+ }
+
+ private static func materialize(_ node: TrieNode, path: [String]) -> RedisKeyNamespaceNode {
+ let children = node.children.values
+ .sorted { $0.segment < $1.segment }
+ .map { materialize($0, path: path + [$0.segment]) }
+ let descendantKeyCount = children.reduce(node.concreteKey == nil ? 0 : 1) {
+ $0 + $1.descendantKeyCount
+ }
+
+ return RedisKeyNamespaceNode(
+ id: nodeID(for: path),
+ segment: node.segment,
+ concreteKey: node.concreteKey,
+ children: children,
+ descendantKeyCount: descendantKeyCount
+ )
+ }
+
+ private static func nodeID(for path: [String]) -> String {
+ path.map { "\($0.utf8.count):\($0)" }.joined(separator: "|")
+ }
+
+ private final class TrieNode {
+ let segment: String
+ var concreteKey: String?
+ var children: [String: TrieNode] = [:]
+
+ init(segment: String) {
+ self.segment = segment
+ }
+ }
+}