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。

12.9 KB
Raw Blame
/**
 * 从源代码里复制出来的「字符串拼接 SQL」还原工具。
 *
 * 使用场景:用户从 Java / JS / TS / Python / Go / C# / Kotlin / PHP 等源码里复制
 * 形如
 *
 *     "SELECT * " +
 *     "FROM users \n " +
 *     "WHERE id = 1"
 *
 * 的拼接 SQL,粘贴进 SQL 编辑器时希望自动去掉字符串引号、`+` 连接符与 `\n`
 * 转义,还原成可直接执行的普通 SQL。
 *
 * 设计原则(宁可「不转换」,也绝不改坏用户内容):
 * 1. 只有当整段文本完全由「字符串字面量 + 合法连接符(空白/+/.)」构成时才尝试还原;
 * 2. 还原结果必须命中 SQL 语句起始关键字,否则视为误判、原样返回;
 * 3. 任何解析失败、超长输入都原样返回,且函数不抛异常。
 */

/** 超过该长度直接放弃解析,避免对超大文本做逐字符扫描 */
export const SQL_SOURCE_PASTE_MAX_LENGTH = 256 * 1024;

/** 还原结果:changed 为 false 时 sql 与输入完全一致,调用方应保持原样粘贴 */
export interface SqlSourcePasteResult {
  /** 还原后的 SQL;未识别时等于输入原文 */
  sql: string;
  /** 是否发生了还原 */
  changed: boolean;
}

/**
 * 还原结果必须命中 SQL 语句起始关键字,用于排除「误把普通源码字符串当 SQL」的情况。
 * 允许前置空白、行注释与块注释。
 */
const SQL_STATEMENT_START_RE =
  /^(?:\s|--[^\n]*\n|\/\*[\s\S]*?\*\/)*(?:SELECT|WITH|INSERT|UPDATE|DELETE|MERGE|REPLACE|UPSERT|CREATE|ALTER|DROP|TRUNCATE|RENAME|CALL|EXEC|EXECUTE|EXPLAIN|SHOW|DESC|DESCRIBE|SET|USE|GRANT|REVOKE|VACUUM|ANALYZE|PRAGMA|BEGIN|START|COMMIT|ROLLBACK|SAVEPOINT|DECLARE|LOCK|UNLOCK)\b/i;

/**
 * 允许出现在第一个字面量之前的「赋值前缀」,例如:
 * `sql = `、`String sql = `、`final String SQL = `、`query := `、`const q = `。
 * 末尾允许一个左括号(覆盖 `sql = ("..." "..." )` 这种写法)。
 * 前缀里不允许出现引号,因此不会吞掉字面量本身。
 * 捕获组 1 为 `=` 之前的前缀文本、捕获组 2 为赋值操作符,用于区分
 * 声明性赋值与裸标识符赋值(见 DECLARATION_KEYWORD_RE)。
 */
const ASSIGNMENT_PREFIX_RE = /^([A-Za-z0-9_$.[\]<>,:\s]*?)(:?=)\s*\(?\s*/;

/**
 * 判定赋值前缀是否「声明性」:出现声明关键字(Java/Kotlin/JS/TS/Go 的
 * 类型或 var/const/let/final/val 等)。`:=`(Go 短声明)也视为声明。
 * 裸标识符赋值(如 `status = 'DELETE'`)不算声明:单个字面量不足以证明
 * 这是「从源码复制的 SQL」,只有出现两个字面量以上的拼接时才还原,
 * 避免把条件片段里的单个 SQL 关键字字符串误改写。
 */
const DECLARATION_KEYWORD_RE = /(?:^|[^A-Za-z0-9_$])(?:string|const|let|var|final|val|def|dim|static)(?:[^A-Za-z0-9_$]|$)/i;

/** 结尾允许出现的收尾字符:空白、行继续符、闭合括号与语句结束分号 */
const TRAILING_TAIL_RE = /^[\s\\]*\)*[\s\\]*;?[\s\\]*$/;

/** 可出现在引号前、用于修饰字符串语义的字母(Python 的 r/b/f/u、C# 的 @/$ 等) */
const LITERAL_PREFIX_CHARS = new Set(["r", "R", "b", "B", "u", "U", "f", "F", "@", "$"]);

/** 两个字面量之间允许的连接符:Java/JS/Go/Python 的 `+`,PHP/Ruby 的 `.` */
const CONNECTOR_CHARS = new Set(["+", "."]);

interface StringLiteralToken {
  /** 已按源码语义还原转义后的内容 */
  content: string;
  /** 字面量结束后的位置(即下一个待解析字符的下标) */
  end: number;
}

/**
 * 跳过空白与行继续符(`\` + 换行),返回新的位置。
 */
function skipBlank(source: string, from: number): number {
  let pos = from;
  while (pos < source.length) {
    const ch = source[pos];
    if (/\s/.test(ch)) {
      pos += 1;
      continue;
    }
    // 行继续符:反斜杠后面紧跟换行,视为空白
    if (ch === "\\" && pos + 1 < source.length && /[\r\n]/.test(source[pos + 1])) {
      pos += 2;
      if (source[pos - 1] === "\r" && source[pos] === "\n") pos += 1;
      continue;
    }
    break;
  }
  return pos;
}

/**
 * 反解「转义字符串」里的转义序列(Java/JS/Python 等非 raw 字面量通用规则)。
 * 未知转义保留反斜杠本身(JS/Python 语义),避免改写 LIKE 模式等内容。
 */
function unescapeLiteralContent(raw: string): string {
  let out = "";
  for (let index = 0; index < raw.length; index += 1) {
    const ch = raw[index];
    if (ch !== "\\") {
      out += ch;
      continue;
    }
    const next = raw[index + 1];
    if (next === undefined) {
      out += "\\";
      continue;
    }
    index += 1;
    switch (next) {
      case "n":
        out += "\n";
        break;
      case "r":
        out += "\r";
        break;
      case "t":
        out += "\t";
        break;
      case "b":
        out += "\b";
        break;
      case "f":
        out += "\f";
        break;
      case "v":
        out += "\v";
        break;
      case "0":
        out += "\0";
        break;
      case "\n":
        // 行继续符:反斜杠 + 换行不产生任何输出
        break;
      case "u": {
        const hex = raw.slice(index + 1, index + 5);
        if (/^[0-9a-fA-F]{4}$/.test(hex)) {
          out += String.fromCharCode(Number.parseInt(hex, 16));
          index += 4;
        } else {
          out += "u";
        }
        break;
      }
      case "x": {
        const hex = raw.slice(index + 1, index + 3);
        if (/^[0-9a-fA-F]{2}$/.test(hex)) {
          out += String.fromCharCode(Number.parseInt(hex, 16));
          index += 2;
        } else {
          out += "x";
        }
        break;
      }
      case "'":
      case '"':
      case "`":
      case "\\":
      case "/":
        // 引号/反斜杠/斜杠的恒等转义:去掉反斜杠本身
        out += next;
        break;
      default:
        // 未知转义:JS/Python 语义是保留反斜杠(如 LIKE '100\%'),
        // Java 里未知转义本就是编译错误,保留反斜杠更贴近用户原文
        out += "\\" + next;
        break;
    }
  }
  return out;
}

/** C# 逐字字符串(@"...")里用 `""` 表示一个双引号,反斜杠不转义 */
function unescapeVerbatimContent(raw: string): string {
  return raw.replace(/""/g, '"');
}

/**
 * 判断引号前是否存在语义前缀(如 `r"` / `f"` / `@$"`),返回前缀起始下标。
 * 只有紧贴引号、且长度不超过 3、且前面不是标识符字符时才算前缀,
 * 避免把 `name"x"` 这类内容误判。
 */
function literalPrefixStart(source: string, quotePos: number): number {
  let start = quotePos;
  while (start > 0 && quotePos - start < 3 && LITERAL_PREFIX_CHARS.has(source[start - 1])) {
    const before = start - 2;
    if (before >= 0 && /[\w$]/.test(source[before])) break;
    start -= 1;
  }
  return start;
}

/**
 * 判断 cursor 处是否是「前缀字母 + 引号」的写法(`r"` / `f"` / `b'` / `@$"` 等),
 * 是则返回引号所在下标;否则返回 null。
 */
function quoteAfterLiteralPrefix(source: string, cursor: number): number | null {
  let pos = cursor;
  while (pos < source.length && pos - cursor < 3 && LITERAL_PREFIX_CHARS.has(source[pos])) pos += 1;
  if (pos === cursor || pos >= source.length) return null;
  return source[pos] === '"' || source[pos] === "'" || source[pos] === "`" ? pos : null;
}

/**
 * 从 cursor 处读取一个字面量,兼容前面带有修饰字母的写法(`r"..."` / `@"..."`)。
 */
function readLiteralAtCursor(source: string, cursor: number): StringLiteralToken | null {
  const directQuote = source[cursor];
  const quotePos = directQuote === '"' || directQuote === "'" || directQuote === "`" ? cursor : quoteAfterLiteralPrefix(source, cursor);
  if (quotePos === null) return null;
  return readStringLiteral(source, quotePos);
}

/**
 * 从 quotePos 处读取一个字符串字面量。支持:
 * - 单引号 / 双引号 / 反引号(JS 模板字符串,`${}` 原样保留);
 * - 三引号文本块(Java、Python 的 `"""` / `'''`);
 * - raw 前缀(Python `r""`)与 C# 逐字字符串(`@"..."`)。
 * 未闭合或不是字面量时返回 null。
 */
function readStringLiteral(source: string, quotePos: number): StringLiteralToken | null {
  const quote = source[quotePos];
  if (quote !== '"' && quote !== "'" && quote !== "`") return null;

  const prefixStart = literalPrefixStart(source, quotePos);
  const prefix = source.slice(prefixStart, quotePos);
  const isRaw = /[rR]/.test(prefix) || prefix.includes("@");
  const isVerbatim = prefix.includes("@");
  const isTriple = source.startsWith(quote.repeat(3), quotePos);
  const openLength = isTriple ? 3 : 1;

  let pos = quotePos + openLength;
  let rawContent = "";
  while (pos < source.length) {
    const ch = source[pos];
    if (!isRaw && ch === "\\") {
      // 转义序列整体交给反解函数处理,这里只负责不要把它当成结束引号
      rawContent += ch;
      if (pos + 1 < source.length) rawContent += source[pos + 1];
      pos += 2;
      continue;
    }
    if (isRaw && ch === "\\" && !isVerbatim) {
      // Python raw 字符串:反斜杠不转义,但保留「反斜杠 + 引号」以免提前截断
      rawContent += ch;
      if (pos + 1 < source.length) rawContent += source[pos + 1];
      pos += 2;
      continue;
    }
    if (isVerbatim && ch === quote && source[pos + 1] === quote) {
      // C# 逐字字符串里 `""` 表示一个双引号,不能当作结束引号
      rawContent += quote + quote;
      pos += 2;
      continue;
    }
    if (isTriple ? source.startsWith(quote.repeat(3), pos) : ch === quote) {
      const end = pos + openLength;
      const content = isVerbatim ? unescapeVerbatimContent(rawContent) : isRaw ? rawContent : unescapeLiteralContent(rawContent);
      return { content, end };
    }
    rawContent += ch;
    pos += 1;
  }
  return null;
}

/**
 * 判断两个字面量之间(between 为其原文)是否为合法拼接:
 * - 隐式拼接(Python/Kotlin):中间只有空白,且确实有空白分隔;
 * - 显式拼接:中间为空白 + `+` 或 `.` + 空白。
 * 其他情况(如 `||`、`,`、函数参数)一律判定为「不是源码拼接」,放弃还原。
 */
function isLiteralSeparator(between: string, sawConnector: boolean): boolean {
  const compact = between.replace(/\\\s/g, "");
  if (sawConnector) return /^\s*[+.]\s*$/.test(compact);
  return compact.length > 0 && /^\s+$/.test(compact);
}

/**
 * 解析整段「源码拼接 SQL」,成功时返回按顺序拼接好的字面量内容列表。
 * 只要出现无法解释的内容就返回 null(调用方据此保持原文粘贴)。
 */
function parseSourceSqlLiterals(source: string): string[] | null {
  let pos = 0;
  const prefixMatch = source.match(ASSIGNMENT_PREFIX_RE);
  let bareAssignment = false;
  if (prefixMatch) {
    // 裸标识符赋值(无声明关键字且不是 :=):只有多字面量拼接才算源码 SQL
    bareAssignment = prefixMatch[2] !== ":=" && !DECLARATION_KEYWORD_RE.test(prefixMatch[1]);
    pos = prefixMatch[0].length;
  }
  pos = skipBlank(source, pos);

  const first = readLiteralAtCursor(source, pos);
  if (!first) return null;
  const fragments = [first.content];
  pos = first.end;

  for (;;) {
    const gapStart = pos;
    let cursor = skipBlank(source, pos);
    let sawConnector = false;
    if (cursor < source.length && CONNECTOR_CHARS.has(source[cursor])) {
      sawConnector = true;
      cursor = skipBlank(source, cursor + 1);
    }

    const next = readLiteralAtCursor(source, cursor);
    if (!next) {
      // 没有更多字面量:只允许「空白 + 可选右括号/分号」收尾
      if (!TRAILING_TAIL_RE.test(source.slice(gapStart))) return null;
      if (bareAssignment && fragments.length < 2) return null;
      return fragments;
    }
    if (!isLiteralSeparator(source.slice(gapStart, cursor), sawConnector)) return null;
    fragments.push(next.content);
    pos = next.end;
  }
}

/**
 * 把从源码复制的拼接 SQL 还原为普通 SQL。
 *
 * @param source 剪贴板里的原文
 * @param maxLength 解析长度上限,超过则原样返回
 * @returns 还原结果;changed 为 false 表示未识别,调用方应原样粘贴
 */
export function restoreSqlFromSourcePaste(source: string, maxLength: number = SQL_SOURCE_PASTE_MAX_LENGTH): SqlSourcePasteResult {
  const unchanged: SqlSourcePasteResult = { sql: source, changed: false };
  if (typeof source !== "string" || source.length === 0 || source.length > maxLength) return unchanged;

  const trimmed = source.trim();
  if (!trimmed) return unchanged;

  const fragments = parseSourceSqlLiterals(trimmed);
  if (!fragments || fragments.length === 0) return unchanged;

  const joined = fragments.join("").trim();
  // 拼接结果为空或与原文完全相同(例如本来就不是字面量拼接)时不改写
  if (!joined || joined === trimmed) return unchanged;
  // 还原结果必须像一条 SQL 语句,否则视为误判
  if (!SQL_STATEMENT_START_RE.test(joined)) return unchanged;

  return { sql: joined, changed: true };
}