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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
fix(desktop): make regex generator values match the pattern
弈秋1e039bfae2c9
diff --git a/apps/desktop/src/components/generate/params/RegexParams.vue b/apps/desktop/src/components/generate/params/RegexParams.vueindex dadd63932d..2256140f15 100644--- a/apps/desktop/src/components/generate/params/RegexParams.vue+++ b/apps/desktop/src/components/generate/params/RegexParams.vue@@ -5,6 +5,7 @@ import { Label } from "@/components/ui/label";import { Button } from "@/components/ui/button";import { RefreshCw } from "@lucide/vue";import type { GeneratorParams } from "@/lib/dataGrid/dataGenerate";+import { generateRegexValue } from "@/lib/dataGrid/regexGenerate";import CommonOptions from "./CommonOptions.vue";import { useI18n } from "vue-i18n";@@ -15,21 +16,11 @@ const { t } = useI18n();const previewKey = ref(0);const previewVal = computed(() => {void previewKey.value;- const p = props.params.pattern ?? "";- if (!p) return t("dataGenerate.notSet");- const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";- try {- const regex = new RegExp("^" + p + "$");- let attempt = "";- for (let i = 0; i < 100; i++) {- const len = p.includes("{") ? parseInt(p.match(/\{(\d+)/)?.[1] ?? "10") : 10;- attempt = Array.from({ length: Math.min(len, 50) }, () => chars[Math.floor(Math.random() * chars.length)]).join("");- if (regex.test(attempt)) return attempt;- }- return attempt || t("dataGenerate.noMatch");- } catch {- return t("dataGenerate.invalidRegex");- }+ const result = generateRegexValue(props.params.pattern, props.params.rawPattern);+ if (result.status === "ok") return result.value;+ if (result.status === "empty") return t("dataGenerate.notSet");+ if (result.status === "invalid") return t("dataGenerate.invalidRegex");+ return t("dataGenerate.noMatch");});function refresh() {diff --git a/apps/desktop/src/lib/dataGrid/__tests__/dataGenerateRegex.spec.ts b/apps/desktop/src/lib/dataGrid/__tests__/dataGenerateRegex.spec.tsnew file mode 100644index 0000000000..178cfafebe--- /dev/null+++ b/apps/desktop/src/lib/dataGrid/__tests__/dataGenerateRegex.spec.ts@@ -0,0 +1,80 @@+import { describe, expect, it } from "vitest";+import { generateValue } from "@/lib/dataGrid/dataGenerate";+import { generateRegexValue } from "@/lib/dataGrid/regexGenerate";++describe("regex data generation (#12077)", () => {+ it("generates values matching the configured pattern instead of value_N fallback", () => {+ const values = Array.from({ length: 50 }, (_, row) => generateValue("username", "character varying(50)", "regex", row, { pattern: "user_[1-9]{5}" }));+ for (const value of values) expect(value).toMatch(/^user_[1-9]{5}$/);+ expect(new Set(values).size).toBeGreaterThan(1);+ });++ it("supports alternation, classes and quantifiers", () => {+ const cases: Array<[string, RegExp]> = [+ ["(foo|bar)_\\d{2,4}", /^(foo|bar)_\d{2,4}$/],+ ["[A-Z]{3}-[a-z]{2}", /^[A-Z]{3}-[a-z]{2}$/],+ ["v\\d+\\.\\d+", /^v\d+\.\d+$/],+ ["order-[0-9a-f]{8}", /^order-[0-9a-f]{8}$/],+ ["\\w+@example\\.com", /^\w+@example\.com$/],+ ];+ for (const [pattern, re] of cases) {+ for (let row = 0; row < 10; row += 1) {+ const value = generateValue("col", "character varying(64)", "regex", row, { pattern });+ expect(value).toMatch(re);+ }+ }+ });++ it("keeps unbounded quantifiers bounded", () => {+ for (let row = 0; row < 10; row += 1) {+ const value = generateValue("col", "character varying(255)", "regex", row, { pattern: "a+b*" }) as string;+ expect(value).toMatch(/^a+b*$/);+ expect(value.length).toBeLessThanOrEqual(16);+ }+ });++ it("generates values for named and back-referencing groups", () => {+ const result = generateRegexValue("(?<year>\\d{4})-(?<month>\\d{2})");+ expect(result.status).toBe("ok");+ if (result.status !== "ok") return;+ expect(result.value).toMatch(/^\d{4}-\d{2}$/);+ const backref = generateRegexValue("(abc)\\1");+ expect(backref.status).toBe("ok");+ if (backref.status !== "ok") return;+ expect(backref.value).toBe("abcabc");+ });++ it("falls back to type defaults for empty or invalid patterns without throwing", () => {+ const empty = generateValue("col", "character varying(20)", "regex", 0, { pattern: "" });+ expect(empty).toBe("value_1");+ const invalid = generateValue("col", "character varying(20)", "regex", 1, { pattern: "(" });+ expect(invalid).toBe("value_2");+ });++ it("reports status instead of throwing for unmatchable patterns", () => {+ expect(generateRegexValue(undefined)).toEqual({ status: "empty" });+ expect(generateRegexValue(" ")).toEqual({ status: "empty" });+ expect(generateRegexValue("(")).toEqual({ status: "invalid" });+ expect(generateRegexValue("(?=a)b")).toEqual({ status: "nomatch" });+ });++ it("raw pattern mode accepts patterns verbatim without auto-anchoring", () => {+ for (let row = 0; row < 10; row += 1) {+ const value = generateValue("col", "character varying(64)", "regex", row, { pattern: "user_\\d+", rawPattern: true }) as string;+ expect(value).toMatch(/user_\d+/);+ }+ });++ it("degrades to fallback instead of throwing for huge counted repeats", () => {+ expect(generateRegexValue("a{2000000000}")).toEqual({ status: "nomatch" });+ const value = generateValue("col", "character varying(20)", "regex", 0, { pattern: "a{2000000000}" });+ expect(value).toBe("value_1");+ });++ it("treats [\\b] in a class as backspace instead of invalid", () => {+ const result = generateRegexValue("[\\b]");+ expect(result.status).toBe("ok");+ if (result.status !== "ok") return;+ expect(result.value).toBe("\b");+ });+});diff --git a/apps/desktop/src/lib/dataGrid/dataGenerate.ts b/apps/desktop/src/lib/dataGrid/dataGenerate.tsindex c039a16808..ece98d2b0a 100644--- a/apps/desktop/src/lib/dataGrid/dataGenerate.ts+++ b/apps/desktop/src/lib/dataGrid/dataGenerate.ts@@ -1,5 +1,6 @@import type { DatabaseType } from "@/types/database";import { qualifiedTableName, quoteTableIdentifier } from "@/lib/table/tableSelectSql";+import { generateRegexValue } from "@/lib/dataGrid/regexGenerate";export interface GeneratorNode {key: string;@@ -1765,6 +1766,10 @@ export function generateValue(columnName: string, dataType: string, generatorKeyreturn randInt(params?.min ?? 1, params?.max ?? 500);}if (key === "image") return `0x${Array.from({ length: 16 }, () => randInt(0, 255).toString(16).padStart(2, "0")).join("")}`;+ if (key === "regex") {+ const generated = generateRegexValue(params?.pattern, params?.rawPattern);+ if (generated.status === "ok") return generated.value;+ }const fn = GeneratorFunctions[key];if (fn) return fn(params);diff --git a/apps/desktop/src/lib/dataGrid/regexGenerate.ts b/apps/desktop/src/lib/dataGrid/regexGenerate.tsnew file mode 100644index 0000000000..cb3ba2462c--- /dev/null+++ b/apps/desktop/src/lib/dataGrid/regexGenerate.ts@@ -0,0 +1,449 @@+// Generate strings that match a user-supplied regular expression (the "regex"+// data generator, #12077). A small recursive-descent parser builds an AST from+// the subset of JS regex syntax that matters for data generation; candidates+// are then validated with the real RegExp engine as the source of truth.+// Unbounded quantifiers are capped so `a+` / `x{2,}` cannot explode, and any+// pattern we cannot satisfy (empty, invalid, or structurally unmatchable) is+// reported so callers can fall back gracefully.++type ClassPart = { ranges: Array<[number, number]>; complement: boolean };++type Node =+ | { t: "empty" }+ | { t: "lit"; s: string }+ | { t: "class"; parts: ClassPart[]; negated: boolean }+ | { t: "dot" }+ | { t: "cat"; items: Node[] }+ | { t: "alt"; opts: Node[] }+ | { t: "rep"; node: Node; min: number; max: number | null }+ | { t: "anchor" }+ | { t: "group"; inner: Node; index: number; name?: string }+ | { t: "backref"; index?: number; name?: string };++export type RegexValueResult = { status: "ok"; value: string } | { status: "empty" | "invalid" | "nomatch" };++const MAX_ATTEMPTS = 8;+const MAX_REPEAT_EXTRA = 32;+const MAX_UNBOUNDED_EXTRA = 4;+// Absolute cap on a single counted repeat: larger min counts (e.g. `a{2000000000}`)+// pass `new RegExp` but would allocate strings past the engine's max length.+const MAX_REPEAT_COUNT = 4096;+const DOT_POOL = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";++const DIGIT_RANGES: Array<[number, number]> = [[48, 57]];+const WORD_RANGES: Array<[number, number]> = [+ [48, 57],+ [65, 90],+ [95, 95],+ [97, 122],+];+const SPACE_RANGES: Array<[number, number]> = [+ [9, 13],+ [32, 32],+];++interface Parser {+ s: string;+ i: number;+ captureCount: number;+}++function escapeClass(ch: string): ClassPart[] {+ switch (ch) {+ case "d":+ return [{ ranges: DIGIT_RANGES, complement: false }];+ case "D":+ return [{ ranges: DIGIT_RANGES, complement: true }];+ case "w":+ return [{ ranges: WORD_RANGES, complement: false }];+ case "W":+ return [{ ranges: WORD_RANGES, complement: true }];+ case "s":+ return [{ ranges: SPACE_RANGES, complement: false }];+ case "S":+ return [{ ranges: SPACE_RANGES, complement: true }];+ default:+ return [];+ }+}++function inRanges(cp: number, ranges: Array<[number, number]>): boolean {+ return ranges.some(([a, b]) => cp >= a && cp <= b);+}++function classMatches(node: Extract<Node, { t: "class" }>, cp: number): boolean {+ let any = false;+ for (const part of node.parts) {+ const hit = inRanges(cp, part.ranges);+ if (part.complement ? !hit : hit) {+ any = true;+ break;+ }+ }+ return node.negated ? !any : any;+}++function safeChar(cp: number): string | null {+ if (cp >= 0xd800 && cp <= 0xdfff) return null;+ return String.fromCodePoint(cp);+}++function pick<T>(arr: T[]): T {+ return arr[Math.floor(Math.random() * arr.length)];+}++function pickFromClass(node: Extract<Node, { t: "class" }>): string | null {+ if (!node.negated && node.parts.every((part) => !part.complement)) {+ const pool: string[] = [];+ for (const part of node.parts) {+ for (const [a, b] of part.ranges) {+ const span = b - a + 1;+ if (span > 128) {+ for (let k = 0; k < 4; k += 1) {+ const ch = safeChar(a + Math.floor(Math.random() * span));+ if (ch) pool.push(ch);+ }+ } else {+ for (let cp = a; cp <= b; cp += 1) {+ const ch = safeChar(cp);+ if (ch) pool.push(ch);+ }+ }+ }+ }+ return pool.length > 0 ? pick(pool) : null;+ }+ for (let attempt = 0; attempt < 64; attempt += 1) {+ const cp = 33 + Math.floor(Math.random() * 93);+ if (classMatches(node, cp)) return String.fromCodePoint(cp);+ }+ return null;+}++function parseEscape(p: Parser, asClass: boolean): Node | ClassPart[] | null {+ p.i += 1;+ const ch = p.s[p.i];+ if (ch === undefined) return null;+ p.i += 1;+ const classParts = escapeClass(ch);+ if (classParts.length > 0) {+ if (asClass) return classParts;+ return { t: "class", parts: classParts, negated: false };+ }+ if (ch === "b") {+ // Inside a class `[\b]` is the backspace character, not a word boundary.+ if (asClass) return [{ ranges: [[8, 8]], complement: false }];+ return { t: "anchor" };+ }+ if (ch === "B") return asClass ? null : { t: "anchor" };+ if (ch === "n") return asClass ? [{ ranges: [[10, 10]], complement: false }] : { t: "lit", s: "\n" };+ if (ch === "r") return asClass ? [{ ranges: [[13, 13]], complement: false }] : { t: "lit", s: "\r" };+ if (ch === "t") return asClass ? [{ ranges: [[9, 9]], complement: false }] : { t: "lit", s: "\t" };+ if (ch === "f") return asClass ? [{ ranges: [[12, 12]], complement: false }] : { t: "lit", s: "\f" };+ if (ch === "v") return asClass ? [{ ranges: [[11, 11]], complement: false }] : { t: "lit", s: "\v" };+ if (ch === "0") return asClass ? [{ ranges: [[0, 0]], complement: false }] : { t: "lit", s: "\0" };+ if (ch === "x") {+ const hex = p.s.slice(p.i, p.i + 2);+ if (/^[0-9a-fA-F]{2}$/.test(hex)) {+ p.i += 2;+ const cp = parseInt(hex, 16);+ return asClass ? [{ ranges: [[cp, cp]], complement: false }] : { t: "lit", s: String.fromCodePoint(cp) };+ }+ return asClass ? [{ ranges: [[120, 120]], complement: false }] : { t: "lit", s: "x" };+ }+ if (ch === "u") {+ const hex = p.s.slice(p.i, p.i + 4);+ if (/^[0-9a-fA-F]{4}$/.test(hex)) {+ p.i += 4;+ const cp = parseInt(hex, 16);+ return asClass ? [{ ranges: [[cp, cp]], complement: false }] : { t: "lit", s: String.fromCodePoint(cp) };+ }+ return asClass ? [{ ranges: [[117, 117]], complement: false }] : { t: "lit", s: "u" };+ }+ if (/[1-9]/.test(ch)) {+ let digits = ch;+ while (/[0-9]/.test(p.s[p.i] ?? "")) {+ digits += p.s[p.i];+ p.i += 1;+ }+ if (asClass) {+ const octal = parseInt(digits, 8);+ const cp = Number.isNaN(octal) ? digits.charCodeAt(0) : Math.min(255, octal);+ return [{ ranges: [[cp, cp]], complement: false }];+ }+ const index = parseInt(digits, 10);+ return { t: "backref", index };+ }+ if (ch === "k" && p.s[p.i] === "<") {+ const close = p.s.indexOf(">", p.i);+ if (close > 0) {+ const name = p.s.slice(p.i + 1, close);+ p.i = close + 1;+ if (asClass) return [{ ranges: [[107, 107]], complement: false }];+ return { t: "backref", name };+ }+ }+ const cp = ch.codePointAt(0) ?? 0;+ return asClass ? [{ ranges: [[cp, cp]], complement: false }] : { t: "lit", s: ch };+}++function parseClass(p: Parser): Node {+ p.i += 1;+ const node: Extract<Node, { t: "class" }> = { t: "class", parts: [], negated: false };+ if (p.s[p.i] === "^") {+ node.negated = true;+ p.i += 1;+ }+ let first = true;+ while (p.i < p.s.length) {+ const c = p.s[p.i];+ if (c === "]" && !first) {+ p.i += 1;+ return node;+ }+ first = false;+ let startCp: number | null = null;+ if (c === "\\") {+ const escaped = parseEscape(p, true);+ if (escaped === null) throw new Error("invalid escape");+ if (Array.isArray(escaped)) node.parts.push(...escaped);+ else startCp = (escaped as { s: string }).s.codePointAt(0) ?? 0;+ } else if (c === "[") {+ const nested = parseClass(p);+ if (nested.t === "class") node.parts.push(...nested.parts.map((part) => ({ ranges: part.ranges, complement: nested.negated ? !part.complement : part.complement })));+ continue;+ } else {+ startCp = c.codePointAt(0) ?? 0;+ p.i += 1;+ }+ if (startCp === null) continue;+ if (p.s[p.i] === "-" && p.s[p.i + 1] !== undefined && p.s[p.i + 1] !== "]") {+ p.i += 1;+ let endCp: number;+ if (p.s[p.i] === "\\") {+ const escaped = parseEscape(p, true);+ if (escaped === null || Array.isArray(escaped)) throw new Error("invalid range end");+ endCp = (escaped as { s: string }).s.codePointAt(0) ?? 0;+ } else {+ endCp = p.s.codePointAt(p.i) ?? 0;+ p.i += 1;+ }+ if (endCp < startCp) [startCp, endCp] = [endCp, startCp];+ node.parts.push({ ranges: [[startCp, endCp]], complement: false });+ } else {+ node.parts.push({ ranges: [[startCp, startCp]], complement: false });+ }+ }+ throw new Error("unterminated class");+}++function parseAtom(p: Parser): Node {+ const c = p.s[p.i];+ if (c === "(") {+ p.i += 1;+ let name: string | undefined;+ let capturing = true;+ if (p.s.startsWith("?:", p.i)) {+ capturing = false;+ p.i += 2;+ } else if (p.s.startsWith("?=", p.i) || p.s.startsWith("?!", p.i)) {+ capturing = false;+ p.i += 2;+ parseAlt(p);+ if (p.s[p.i] !== ")") throw new Error("expected )");+ p.i += 1;+ return { t: "anchor" };+ } else if (p.s.startsWith("?<=", p.i) || p.s.startsWith("?<!", p.i)) {+ capturing = false;+ p.i += 4;+ parseAlt(p);+ if (p.s[p.i] !== ")") throw new Error("expected )");+ p.i += 1;+ return { t: "anchor" };+ } else if (p.s.startsWith("?<", p.i)) {+ const close = p.s.indexOf(">", p.i + 2);+ if (close < 0) throw new Error("unterminated group name");+ name = p.s.slice(p.i + 2, close);+ p.i = close + 1;+ }+ let index = 0;+ if (capturing) {+ index = p.captureCount + 1;+ p.captureCount = index;+ }+ const inner = parseAlt(p);+ if (p.s[p.i] !== ")") throw new Error("expected )");+ p.i += 1;+ if (!capturing) return inner;+ return { t: "group", inner, index, name };+ }+ if (c === "[") return parseClass(p);+ if (c === ".") {+ p.i += 1;+ return { t: "dot" };+ }+ if (c === "^" || c === "$") {+ p.i += 1;+ return { t: "anchor" };+ }+ if (c === "\\") {+ const escaped = parseEscape(p, false);+ if (escaped === null || Array.isArray(escaped)) throw new Error("invalid escape");+ return escaped;+ }+ const cp = p.s.codePointAt(p.i) ?? 0;+ p.i += cp > 0xffff ? 2 : 1;+ return { t: "lit", s: String.fromCodePoint(cp) };+}++function parseQuantifier(p: Parser, atom: Node): Node {+ let min = 0;+ let max: number | null = null;+ const c = p.s[p.i];+ if (c === "*") {+ min = 0;+ max = null;+ p.i += 1;+ } else if (c === "+") {+ min = 1;+ max = null;+ p.i += 1;+ } else if (c === "?") {+ min = 0;+ max = 1;+ p.i += 1;+ } else if (c === "{") {+ const m = /^\{(\d+)(,(\d*)?)?\}/.exec(p.s.slice(p.i));+ if (!m) return atom;+ min = parseInt(m[1], 10);+ if (m[2] === undefined) max = min;+ else if (!m[3]) max = null;+ else max = Math.max(min, parseInt(m[3], 10));+ p.i += m[0].length;+ } else {+ return atom;+ }+ if (p.s[p.i] === "?") p.i += 1;+ return { t: "rep", node: atom, min, max };+}++function parseConcat(p: Parser): Node {+ const items: Node[] = [];+ while (p.i < p.s.length) {+ const c = p.s[p.i];+ if (c === "|" || c === ")") break;+ items.push(parseQuantifier(p, parseAtom(p)));+ }+ return items.length === 0 ? { t: "empty" } : items.length === 1 ? items[0] : { t: "cat", items };+}++function parseAlt(p: Parser): Node {+ const opts: Node[] = [parseConcat(p)];+ while (p.s[p.i] === "|") {+ p.i += 1;+ opts.push(parseConcat(p));+ }+ return opts.length === 1 ? opts[0] : { t: "alt", opts };+}++function parsePattern(src: string): Node {+ const p: Parser = { s: src, i: 0, captureCount: 0 };+ const node = parseAlt(p);+ if (p.i < p.s.length) throw new Error("unexpected )");+ return node;+}++interface Ctx {+ captures: Array<string | null>;+ names: Map<string, string>;+}++function gen(node: Node, ctx: Ctx): string | null {+ switch (node.t) {+ case "empty":+ case "anchor":+ return "";+ case "lit":+ return node.s;+ case "dot":+ return pick(Array.from(DOT_POOL));+ case "class":+ return pickFromClass(node);+ case "cat": {+ let out = "";+ for (const item of node.items) {+ const part = gen(item, ctx);+ if (part === null) return null;+ out += part;+ }+ return out;+ }+ case "alt":+ return gen(pick(node.opts), ctx);+ case "group": {+ const inner = gen(node.inner, ctx);+ if (inner === null) return null;+ ctx.captures[node.index - 1] = inner;+ if (node.name) ctx.names.set(node.name, inner);+ return inner;+ }+ case "backref": {+ if (node.name !== undefined) return ctx.names.get(node.name) ?? null;+ if (node.index !== undefined) return ctx.captures[node.index - 1] ?? null;+ return null;+ }+ case "rep": {+ if (node.min > MAX_REPEAT_COUNT) return null;+ const bound = node.max === null ? node.min + MAX_UNBOUNDED_EXTRA : Math.min(node.max, node.min + MAX_REPEAT_EXTRA);+ const count = node.min + Math.floor(Math.random() * (bound - node.min + 1));+ let out = "";+ for (let i = 0; i < count; i += 1) {+ const part = gen(node.node, ctx);+ if (part === null) return null;+ out += part;+ }+ return out;+ }+ }+}++interface Compiled {+ re: RegExp;+ ast: Node;+}++const cache = new Map<string, Compiled | null>();++function compile(pattern: string, raw: boolean): Compiled | null {+ const key = `${raw ? "r" : "a"}\u0000${pattern}`;+ const hit = cache.get(key);+ if (hit !== undefined) return hit;+ let compiled: Compiled | null = null;+ try {+ const re = new RegExp(raw ? pattern : `^(?:${pattern})$`);+ compiled = { re, ast: parsePattern(pattern) };+ } catch {+ compiled = null;+ }+ if (cache.size > 64) cache.clear();+ cache.set(key, compiled);+ return compiled;+}++export function generateRegexValue(pattern: string | undefined, rawPattern?: boolean): RegexValueResult {+ const source = pattern ?? "";+ if (source.trim() === "") return { status: "empty" };+ const compiled = compile(source, rawPattern === true);+ if (!compiled) return { status: "invalid" };+ for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {+ const ctx: Ctx = { captures: [], names: new Map() };+ try {+ const value = gen(compiled.ast, ctx);+ if (value !== null && compiled.re.test(value)) return { status: "ok", value };+ } catch {+ // Generation is best-effort; any runtime failure (e.g. string-length+ // limits) degrades to the nomatch fallback instead of aborting the table.+ }+ }+ return { status: "nomatch" };+}