Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

10.5 KB
Raw Blame
import type { RedisKeyInfo } from "@/lib/backend/api";
import { compileRedisKeyGroups, type RedisKeyGroupRule } from "./redisKeyGrouping";

export interface RedisVirtualGroupRow {
  kind: "virtual-group";
  id: string;
  label: string;
  depth: number;
  count: number;
}
export interface RedisGroupedKeyRow {
  kind: "key";
  id: string;
  key: RedisKeyInfo;
  label: string;
  depth: number;
}
export type RedisGroupedRow = RedisVirtualGroupRow | RedisGroupedKeyRow;
export interface RedisOuterGroupBoundary {
  start: number;
  end: number;
  row: RedisVirtualGroupRow;
}
export interface RedisHeaderBoundary extends RedisOuterGroupBoundary {
  parent?: RedisHeaderBoundary;
}

/** Header-only binary lookup plus parent links; never reads leaf rows. */
export function findRedisHeaderChain(headers: readonly RedisHeaderBoundary[], position: number): RedisHeaderBoundary[] {
  let low = 0;
  let high = headers.length;
  while (low < high) {
    const mid = (low + high) >>> 1;
    if (headers[mid]!.start <= position) low = mid + 1;
    else high = mid;
  }
  let header: RedisHeaderBoundary | undefined = headers[low - 1];
  const chain: RedisHeaderBoundary[] = [];
  while (header) {
    if (position < header.end) chain.push(header);
    header = header.parent;
  }
  return chain.reverse();
}

/** Only searches outer sections (at most 65), never the virtual key source. */
export function findRedisOuterGroup(groups: readonly RedisOuterGroupBoundary[], position: number): RedisOuterGroupBoundary | undefined {
  let low = 0;
  let high = groups.length - 1;
  while (low <= high) {
    const mid = (low + high) >>> 1;
    const group = groups[mid]!;
    if (position < group.start) high = mid - 1;
    else if (position >= group.end) low = mid + 1;
    else return group;
  }
  return undefined;
}
interface Namespace {
  id: string;
  label: string;
  count: number;
  children: Map<string, Namespace>;
  keys: RedisKeyInfo[];
}
interface Group {
  id: string;
  label: string;
  keys: RedisKeyInfo[];
  tree?: Namespace;
  treeLength: number;
}
export interface GroupWork {
  current: () => boolean;
  yield: () => Promise<void>;
}
const CHUNK = 512;

/** Non-reactive index: ordinary append batches classify only new identities. */
export class RedisKeyGroupIndex {
  readonly groups: Group[];
  private readonly classify: ReturnType<typeof compileRedisKeyGroups>;
  private readonly byId = new Map<string | null, Group>();
  private readonly locations = new Map<string, { group: Group; offset: number; namespace?: Namespace; namespaceOffset?: number }>();
  private consumed = 0;
  private lastRaw: string | undefined;

  constructor(rules: readonly RedisKeyGroupRule[], unmatched: string) {
    this.classify = compileRedisKeyGroups(rules);
    this.groups = rules
      .filter((rule) => rule.enabled)
      .map((rule) => {
        const group = { id: `custom:${JSON.stringify(rule.id)}`, label: rule.name, keys: [], treeLength: 0 };
        this.byId.set(rule.id, group);
        return group;
      });
    const group = { id: "custom:unmatched", label: unmatched, keys: [], treeLength: 0 };
    this.byId.set(null, group);
    this.groups.push(group);
  }

  canAppend(keys: readonly RedisKeyInfo[]): boolean {
    return keys.length >= this.consumed && (!this.consumed || keys[this.consumed - 1]?.key_raw === this.lastRaw);
  }

  async append(keys: readonly RedisKeyInfo[], work: GroupWork): Promise<boolean> {
    for (let offset = this.consumed; offset < keys.length;) {
      if (!work.current()) return false;
      const end = Math.min(offset + CHUNK, keys.length);
      for (; offset < end; offset++) {
        const key = keys[offset]!;
        if (this.locations.has(key.key_raw)) continue;
        const group = this.byId.get(this.classify(key.key_raw))!;
        this.locations.set(key.key_raw, { group, offset: group.keys.length });
        group.keys.push(key);
      }
      this.consumed = offset;
      this.lastRaw = keys[offset - 1]?.key_raw;
      if (offset < keys.length) await work.yield();
    }
    return work.current();
  }

  async project(view: "list" | "tree", separator: string, expanded: ReadonlySet<string>, work: GroupWork): Promise<{ rows: RedisGroupedRow[]; outerGroups: RedisOuterGroupBoundary[]; headerBoundaries: RedisHeaderBoundary[]; positions: { get: (id: string) => number | undefined } } | null> {
    // Row ranges reference canonical key arrays. A million-key list projection
    // is O(groups), not O(keys) per incoming batch, and only mounted leaves
    // allocate presentation objects. Captured lengths make publication atomic.
    const ranges: { start: number; length: number; row?: RedisVirtualGroupRow; keys?: readonly RedisKeyInfo[]; depth: number }[] = [];
    const headers = new Map<string, number>();
    const outerGroups: RedisOuterGroupBoundary[] = [];
    const headerBoundaries: RedisHeaderBoundary[] = [];
    const openHeaders: RedisHeaderBoundary[] = [];
    const keyRanges = new Map<string, number>();
    let length = 0;
    let units = 0;
    const checkpoint = async () => {
      if (++units % CHUNK === 0) await work.yield();
      return work.current();
    };
    const add = (row: RedisVirtualGroupRow) => {
      while (openHeaders.length && openHeaders[openHeaders.length - 1]!.row.depth >= row.depth) openHeaders.pop()!.end = length;
      const boundary = { start: length, end: length + 1, row, parent: openHeaders[openHeaders.length - 1] };
      headerBoundaries.push(boundary);
      openHeaders.push(boundary);
      headers.set(row.id, length);
      ranges.push({ start: length++, length: 1, row, depth: row.depth });
    };
    const addKeys = (id: string, keys: readonly RedisKeyInfo[], depth: number) => {
      keyRanges.set(id, length);
      if (keys.length) ranges.push({ start: length, length: keys.length, keys, depth });
      length += keys.length;
    };
    const leaf = (key: RedisKeyInfo, label: string, depth: number): RedisGroupedKeyRow => ({ kind: "key", id: `key:${key.key_raw}`, key, label, depth });
    for (const group of this.groups) {
      if (!work.current()) return null;
      if (group.id === "custom:unmatched" && !group.keys.length) continue;
      const previous = outerGroups[outerGroups.length - 1];
      if (previous) previous.end = length;
      const row: RedisVirtualGroupRow = { kind: "virtual-group", id: group.id, label: group.label, depth: 0, count: group.keys.length };
      outerGroups.push({ start: length, end: length + 1, row });
      add(row);
      if (!expanded.has(group.id)) continue;
      if (view === "list" || !separator) {
        addKeys(group.id, group.keys, 1);
      } else {
        // A namespace index is built only for an expanded outer group. It holds
        // references to canonical records, not copies of metadata.
        group.tree ??= { id: group.id, label: "", count: 0, children: new Map(), keys: [] };
        for (let i = group.treeLength; i < group.keys.length; i++) {
          const key = group.keys[i]!;
          const parts = key.key_display.split(separator);
          let node = group.tree;
          const path: string[] = [];
          node.count++;
          for (const part of parts.slice(0, -1)) {
            path.push(part);
            let child = node.children.get(part);
            if (!child) {
              child = { id: `${group.id}:namespace:${JSON.stringify(path)}`, label: part, count: 0, children: new Map(), keys: [] };
              node.children.set(part, child);
            }
            child.count++;
            node = child;
          }
          const location = this.locations.get(key.key_raw)!;
          location.namespace = node;
          location.namespaceOffset = node.keys.length;
          node.keys.push(key);
          group.treeLength = i + 1;
          if (!(await checkpoint())) return null;
        }
        const stack: { children: Iterator<Namespace>; depth: number }[] = [{ children: group.tree.children.values(), depth: 1 }];
        addKeys(group.tree.id, group.tree.keys, 1);
        while (stack.length) {
          const frame = stack[stack.length - 1]!;
          const result = frame.children.next();
          if (result.done) {
            stack.pop();
            continue;
          }
          const node = result.value;
          add({ kind: "virtual-group", id: node.id, label: node.label, depth: frame.depth, count: node.count });
          if (expanded.has(node.id)) {
            addKeys(node.id, node.keys, frame.depth + 1);
            stack.push({ children: node.children.values(), depth: frame.depth + 1 });
          }
          if (!(await checkpoint())) return null;
        }
      }
    }
    const lastGroup = outerGroups[outerGroups.length - 1];
    if (lastGroup) lastGroup.end = length;
    for (const header of openHeaders) header.end = length;
    const at = (index: number): RedisGroupedRow | undefined => {
      if (index < 0 || index >= length) return undefined;
      let low = 0;
      let high = ranges.length - 1;
      while (low <= high) {
        const mid = (low + high) >>> 1;
        const range = ranges[mid]!;
        if (index < range.start) high = mid - 1;
        else if (index >= range.start + range.length) low = mid + 1;
        else {
          if (range.row) return range.row;
          const key = range.keys![index - range.start]!;
          const parts = view === "tree" && separator ? key.key_display.split(separator) : [key.key_display];
          return leaf(key, parts[parts.length - 1] ?? "", range.depth);
        }
      }
      return undefined;
    };
    const rows = new Proxy([] as RedisGroupedRow[], {
      get(target, property, receiver) {
        if (property === "length") return length;
        const n = typeof property === "string" && /^(0|[1-9]\d*)$/.test(property) ? Number(property) : -1;
        return n >= 0 ? at(n) : Reflect.get(target, property, receiver);
      },
      has(target, property) {
        const n = typeof property === "string" && /^(0|[1-9]\d*)$/.test(property) ? Number(property) : -1;
        return n >= 0 ? n < length : Reflect.has(target, property);
      },
    });
    const positions = {
      get: (id: string) => {
        if (!id.startsWith("key:")) return headers.get(id);
        const location = this.locations.get(id.slice(4));
        if (!location) return undefined;
        const tree = view === "tree" && !!separator;
        const start = keyRanges.get(tree ? (location.namespace?.id ?? "") : location.group.id);
        return start === undefined ? undefined : start + (tree ? location.namespaceOffset! : location.offset);
      },
    };
    return work.current() ? { rows, outerGroups, headerBoundaries, positions } : null;
  }
}