Files
dbx/apps/desktop/src/lib/sql/sqlSourcePaste.ts
T

349 lines
13 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* 从源代码里复制出来的「字符串拼接 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 };
}