package cn.iocoder.yudao.module.qcreport.engine.rule;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Set;
|
import java.util.regex.Pattern;
|
|
/**
|
* 规则文本 → 语法树。
|
* <p>
|
* 与前端 {@code engine/rule-engine.ts} 的 tokenize + Parser 一一对应，
|
* 支持的语法见 docs/智能质检报告平台-方案设计.md §13。
|
*/
|
public final class RuleParser {
|
|
private static final Set<String> KEYWORDS = Set.of(
|
"AND", "BETWEEN", "FALSE", "IN", "NOT", "NOT_IN", "NULL", "OR", "TRUE");
|
|
private static final Set<String> TWO_CHAR_OPERATORS = Set.of("<=", ">=", "!=", "<>", "==");
|
|
private static final String SINGLE_CHAR_OPERATORS = "><=+-*/!";
|
|
private static final Pattern NUMBER_TEXT = Pattern.compile("^\\d+(?:\\.\\d+)?$");
|
|
private static final Pattern DIGIT_TEXT = Pattern.compile("^\\d+$");
|
|
private RuleParser() {
|
}
|
|
/** 解析规则文本，语法错误抛 {@link RuleSyntaxException} */
|
public static RuleNode parse(String expression) {
|
String trimmed = expression == null ? "" : expression.trim();
|
if (trimmed.isEmpty()) {
|
throw new RuleSyntaxException("规则表达式为空", 0);
|
}
|
return new Parser(tokenize(trimmed)).parse();
|
}
|
|
/* ------------------------------ 词法分析 ------------------------------ */
|
|
private static List<RuleToken> tokenize(String source) {
|
List<RuleToken> tokens = new ArrayList<>();
|
int length = source.length();
|
int index = 0;
|
|
while (index < length) {
|
char ch = source.charAt(index);
|
|
if (Character.isWhitespace(ch)) {
|
index++;
|
continue;
|
}
|
|
if (ch == '\'' || ch == '"') {
|
index = readString(source, index, ch, tokens);
|
continue;
|
}
|
|
if (ch >= '0' && ch <= '9') {
|
int cursor = index;
|
while (cursor < length && isDigitOrDot(source.charAt(cursor))) {
|
cursor++;
|
}
|
String text = source.substring(index, cursor);
|
if (!NUMBER_TEXT.matcher(text).matches()) {
|
throw new RuleSyntaxException("数字格式不正确：" + text, index);
|
}
|
tokens.add(new RuleToken(TokenType.NUMBER, text, index));
|
index = cursor;
|
continue;
|
}
|
|
if (isIdentStart(ch)) {
|
index = readWord(source, index, tokens);
|
continue;
|
}
|
|
if (index + 2 <= length && TWO_CHAR_OPERATORS.contains(source.substring(index, index + 2))) {
|
tokens.add(new RuleToken(TokenType.OPERATOR, source.substring(index, index + 2), index));
|
index += 2;
|
continue;
|
}
|
|
if (ch == '(' || ch == ')') {
|
tokens.add(new RuleToken(ch == '(' ? TokenType.LPAREN : TokenType.RPAREN, String.valueOf(ch), index));
|
index++;
|
continue;
|
}
|
if (ch == ',') {
|
tokens.add(new RuleToken(TokenType.COMMA, String.valueOf(ch), index));
|
index++;
|
continue;
|
}
|
if (SINGLE_CHAR_OPERATORS.indexOf(ch) >= 0) {
|
tokens.add(new RuleToken(TokenType.OPERATOR, String.valueOf(ch), index));
|
index++;
|
continue;
|
}
|
|
throw new RuleSyntaxException("无法识别的字符「" + ch + "」", index);
|
}
|
|
tokens.add(new RuleToken(TokenType.EOF, "", length));
|
return tokens;
|
}
|
|
/** 读一个字符串字面量，返回结束后的下标 */
|
private static int readString(String source, int start, char quote, List<RuleToken> tokens) {
|
int length = source.length();
|
StringBuilder value = new StringBuilder();
|
int cursor = start + 1;
|
while (cursor < length && source.charAt(cursor) != quote) {
|
if (source.charAt(cursor) == '\\' && cursor + 1 < length) {
|
value.append(source.charAt(cursor + 1));
|
cursor += 2;
|
continue;
|
}
|
value.append(source.charAt(cursor));
|
cursor++;
|
}
|
if (cursor >= length) {
|
throw new RuleSyntaxException("字符串缺少结尾引号", start);
|
}
|
tokens.add(new RuleToken(TokenType.STRING, value.toString(), start));
|
return cursor + 1;
|
}
|
|
/**
|
* 读一个标识符/路径，返回结束后的下标。
|
* <p>
|
* 路径尾巴（.属性 与 [下标]）在词法阶段就并进同一个词，取值时整条路径一次解析。
|
*/
|
private static int readWord(String source, int start, List<RuleToken> tokens) {
|
int length = source.length();
|
int cursor = start;
|
while (cursor < length && isIdentPart(source.charAt(cursor))) {
|
cursor++;
|
}
|
StringBuilder value = new StringBuilder(source.substring(start, cursor));
|
while (cursor < length) {
|
char next = source.charAt(cursor);
|
if (next == '.' && cursor + 1 < length && isIdentStart(source.charAt(cursor + 1))) {
|
int end = cursor + 1;
|
while (end < length && isIdentPart(source.charAt(end))) {
|
end++;
|
}
|
value.append(source, cursor, end);
|
cursor = end;
|
continue;
|
}
|
if (next == '[') {
|
int close = source.indexOf(']', cursor);
|
if (close == -1) {
|
throw new RuleSyntaxException("数组下标缺少 ]", cursor);
|
}
|
String inner = source.substring(cursor + 1, close).trim();
|
if (!DIGIT_TEXT.matcher(inner).matches()) {
|
throw new RuleSyntaxException("数组下标只能是数字：" + inner, cursor);
|
}
|
value.append('[').append(inner).append(']');
|
cursor = close + 1;
|
continue;
|
}
|
break;
|
}
|
tokens.add(new RuleToken(TokenType.WORD, value.toString(), start));
|
return cursor;
|
}
|
|
private static boolean isIdentStart(char ch) {
|
return ch >= 'A' && ch <= 'Z' || ch >= 'a' && ch <= 'z' || ch == '_' || ch == '$';
|
}
|
|
private static boolean isIdentPart(char ch) {
|
return isIdentStart(ch) || ch >= '0' && ch <= '9';
|
}
|
|
private static boolean isDigitOrDot(char ch) {
|
return ch >= '0' && ch <= '9' || ch == '.';
|
}
|
|
/* ------------------------------ 语法分析 ------------------------------ */
|
|
private static final class Parser {
|
|
private final List<RuleToken> tokens;
|
private int cursor;
|
|
private Parser(List<RuleToken> tokens) {
|
this.tokens = tokens;
|
}
|
|
private RuleNode parse() {
|
RuleNode node = parseOr();
|
RuleToken token = peek();
|
if (token.type() != TokenType.EOF) {
|
throw new RuleSyntaxException("多余的内容：" + token.value(), token.position());
|
}
|
return node;
|
}
|
|
private RuleNode parseOr() {
|
RuleNode left = parseAnd();
|
while (matchWord("OR")) {
|
left = new RuleNode.Binary("OR", left, parseAnd());
|
}
|
return left;
|
}
|
|
private RuleNode parseAnd() {
|
RuleNode left = parseComparison();
|
while (matchWord("AND")) {
|
left = new RuleNode.Binary("AND", left, parseComparison());
|
}
|
return left;
|
}
|
|
private RuleNode parseComparison() {
|
RuleNode left = parseAdditive();
|
|
if (matchWord("BETWEEN")) {
|
RuleNode lower = parseAdditive();
|
if (!matchWord("AND")) {
|
throw new RuleSyntaxException("BETWEEN 缺少 AND 与上界", peek().position());
|
}
|
RuleNode upper = parseAdditive();
|
return new RuleNode.Between(left, lower, upper, false);
|
}
|
|
if (matchWord("NOT")) {
|
if (matchWord("IN") || matchWord("NOT_IN")) {
|
return new RuleNode.In(left, parseList(), true);
|
}
|
throw new RuleSyntaxException("NOT 只能用于 NOT IN", peek().position());
|
}
|
|
if (matchWord("IN")) {
|
return new RuleNode.In(left, parseList(), false);
|
}
|
|
RuleToken token = peek();
|
if (token.type() == TokenType.OPERATOR
|
&& "< <= = == != <> > >=".contains(token.value())) {
|
cursor++;
|
return new RuleNode.Binary(normalizeOperator(token.value()), left, parseAdditive());
|
}
|
|
return left;
|
}
|
|
/** == 统一成 =、<> 统一成 !=，求值阶段只认一种写法 */
|
private static String normalizeOperator(String operator) {
|
if ("==".equals(operator)) {
|
return "=";
|
}
|
return "<>".equals(operator) ? "!=" : operator;
|
}
|
|
private List<RuleNode> parseList() {
|
expect(TokenType.LPAREN);
|
List<RuleNode> items = new ArrayList<>();
|
if (peek().type() != TokenType.RPAREN) {
|
items.add(parseOr());
|
while (peek().type() == TokenType.COMMA) {
|
cursor++;
|
items.add(parseOr());
|
}
|
}
|
expect(TokenType.RPAREN);
|
return items;
|
}
|
|
private RuleNode parseAdditive() {
|
RuleNode left = parseMultiplicative();
|
for (; ; ) {
|
RuleToken token = peek();
|
if (token.type() != TokenType.OPERATOR || !"+".equals(token.value()) && !"-".equals(token.value())) {
|
return left;
|
}
|
cursor++;
|
left = new RuleNode.Binary(token.value(), left, parseMultiplicative());
|
}
|
}
|
|
private RuleNode parseMultiplicative() {
|
RuleNode left = parseUnary();
|
for (; ; ) {
|
RuleToken token = peek();
|
if (token.type() != TokenType.OPERATOR || !"*".equals(token.value()) && !"/".equals(token.value())) {
|
return left;
|
}
|
cursor++;
|
left = new RuleNode.Binary(token.value(), left, parseUnary());
|
}
|
}
|
|
private RuleNode parseUnary() {
|
RuleToken token = peek();
|
if (token.type() == TokenType.OPERATOR && ("-".equals(token.value()) || "!".equals(token.value()))) {
|
cursor++;
|
return new RuleNode.Unary(token.value(), parseUnary());
|
}
|
return parsePrimary();
|
}
|
|
private RuleNode parsePrimary() {
|
RuleToken token = peek();
|
|
if (token.type() == TokenType.NUMBER) {
|
cursor++;
|
return new RuleNode.Literal(Double.valueOf(token.value()));
|
}
|
if (token.type() == TokenType.STRING) {
|
cursor++;
|
return new RuleNode.Literal(token.value());
|
}
|
if (token.type() == TokenType.LPAREN) {
|
cursor++;
|
RuleNode node = parseOr();
|
expect(TokenType.RPAREN);
|
return node;
|
}
|
if (token.type() == TokenType.WORD) {
|
cursor++;
|
String upper = token.value().toUpperCase();
|
if ("TRUE".equals(upper)) {
|
return new RuleNode.Literal(Boolean.TRUE);
|
}
|
if ("FALSE".equals(upper)) {
|
return new RuleNode.Literal(Boolean.FALSE);
|
}
|
if ("NULL".equals(upper)) {
|
return new RuleNode.Literal(null);
|
}
|
if (peek().type() == TokenType.LPAREN) {
|
return new RuleNode.Call(upper, parseList());
|
}
|
if (KEYWORDS.contains(upper)) {
|
throw new RuleSyntaxException("关键字 " + upper + " 的位置不正确", token.position());
|
}
|
return new RuleNode.Path(token.value());
|
}
|
|
throw new RuleSyntaxException(
|
token.type() == TokenType.EOF ? "表达式不完整" : "无法解析的内容：" + token.value(),
|
token.position());
|
}
|
|
private RuleToken peek() {
|
return tokens.get(cursor);
|
}
|
|
private boolean matchWord(String word) {
|
RuleToken token = peek();
|
if (token.type() == TokenType.WORD && token.value().toUpperCase().equals(word)) {
|
cursor++;
|
return true;
|
}
|
return false;
|
}
|
|
private void expect(TokenType type) {
|
RuleToken token = peek();
|
if (token.type() != type) {
|
throw new RuleSyntaxException(
|
"应该是 " + type.label() + "，实际是「" + token.value() + "」", token.position());
|
}
|
cursor++;
|
}
|
}
|
|
}
|
