语法解析器续:case..when..语法解析计算
作者:互联网
之前写过一篇博客,是关于如何解析类似sql之类的解析器实现参考:https://www.cnblogs.com/yougewe/p/13774289.html
之前的解析器,更多的是是做语言的翻译转换工作,并不涉及具体的数据运算。而且抛弃了许多上下文关联语法处理,所以相对还是简单的。
那么,如果我们想做一下数据运算呢?比如我给你一些值,然后给你一个表达式,你可以给出其运算结果吗?
1. 表达式运算难度如何?
比如,已知表达式为, field1 > 0 and field2 > 0, 然后已知道值 field1 = 1, field2 = 2; 那么,此运算结果必当为true。这很理所当然!
但以上,仅为人工处理,自己用大脑做了下运算,得到结果。如果转换为代码,又当如何?
我想,我们至少要做这么几件事:
1. 解析出所有字段有field1, field2;
2. 解析出比较运算符 >;
3. 解析出右边具体的比较值;
4. 解析出连接运算符and;
5. 做所有的比较运算;
6. 关联优先级得到最终结果;
怎么样?现在还觉得很简单吗?如果是,请收下我的膝盖!
但是,如果真要做这种泛化的场景,那就相当相当复杂了,要知道类似于HIVE之类的重量级产品,语法解析都是其中重要的组成部分。实际上,这可能涉及到相当多的语言规范需要做了。所以,必然超出我们的简化理解范围。
所以,我这里仅挑一个简单场景做解析:即如题所说,case..when..的解析。
所以,我们可以范围缩减为,给定表达式:case when field1 > 0 then 'f1' else 'fn' end; 的判断解析。比如给定值 field1=1, 则应得到结果 f1, 如果给定值 field1=0, 则应得到结果 fn.
在划定范围之后,好像更有了目标感了。但是问题真的简单了吗?实际上,还是有相当多的分支需要处理的,因为case..when..中可以嵌套其他语法。所以,我们只能尽力而为了。
2. case..when..表达式运算的实现
命题确立之后,我们可以开始着手如何实现了。如上描述,我们有两个已知条件:表达式和基础值。
基于上一篇文章的解析,我们基本可以快速得到所有组成case when 的元素token信息了。这就为我们省去了不少事。这里,我着重给一个如何获取整个case..when..词句的实现,使其可形成一个独立的词组。
// 将case..when.. 归结为sql类关键词的实现中 public SqlKeywordAstHandler(TokenDescriptor masterToken, Iterator<TokenDescriptor> candidates, TokenTypeEnum tokenType) { super(masterToken, candidates, tokenType); String word = masterToken.getRawWord().toLowerCase(); if("case".equals(word)) { completeCaseWhenTokens(candidates); } } /** * 实例case...when... 词汇列表 * * @param candidates 待用词汇 */ private void completeCaseWhenTokens(Iterator<TokenDescriptor> candidates) { boolean syntaxClosed = false; while (candidates.hasNext()) { TokenDescriptor token = candidates.next(); addExtendToken(token); if("end".equalsIgnoreCase(token.getRawWord())) { syntaxClosed = true; break; } } if(!syntaxClosed) { throw new SyntaxException("语法错误:case..when..未半闭合"); } }
以上,就是获取case..when..词组的方法了,主要就是从case开始,到end结束,中间的所有词根,都被划作其范围。当然,还有一个重要的点,是将数据字段找出来,放到可取到的地方。
有了一个个独立的元素,我们就可以进行语义分析了。该分析可以放在该解析器中,但也许并不会太通用,所以,此处我将其抽象为一个单独的值运算类。在需要的地方,再实例化该运算类,即可。核心问题如上一节中描述,具体实现代码如下:
import com.my.mvc.app.common.exception.SyntaxException; import com.my.mvc.app.common.helper.parser.SyntaxStatement; import com.my.mvc.app.common.helper.parser.TokenDescriptor; import com.my.mvc.app.common.helper.parser.TokenTypeEnum; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.StringUtils; import java.math.BigDecimal; import java.util.*; import java.util.stream.Collectors; /** * 功能描述: case..when.. 真实数据运算帮助类 * */ @Slf4j public class CaseWhenElDataCalcHelper { /** * case when 完整语法 */ private SyntaxStatement caseWhenStmt; public CaseWhenElDataCalcHelper(SyntaxStatement caseWhenStmt) { this.caseWhenStmt = caseWhenStmt; } /** * 计算case..when的结果 * * @param suppliers 原始所有值 * @return 最终计算出的值 */ public String calcCaseWhenData(Map<String, String> suppliers) { List<TokenDescriptor> allTokens = caseWhenStmt.getAllTokens(); TokenDescriptor masterToken = allTokens.get(0); if(!"case".equalsIgnoreCase(masterToken.getRawWord())) { throw new SyntaxException("不是case..when..表达式"); } int tokenLen = allTokens.size(); if(tokenLen < 3) { throw new SyntaxException("case..when..表达式语法错误"); } TokenDescriptor closureToken = allTokens.get(tokenLen - 1); if(!"end".equalsIgnoreCase(closureToken.getRawWord())) { throw new SyntaxException("case..when..表达式未闭合"); } // 暂只支持 case when xxx then xxx... end 语法 // 不支持 case field_name when 1 then '1'... end, 即单字段判定不支持 List<TokenDescriptor> whenExpressionCandidates; for (int i = 1; i < tokenLen - 1; i++) { whenExpressionCandidates = new ArrayList<>(); TokenDescriptor currentToken = allTokens.get(i); if("when".equalsIgnoreCase(currentToken.getRawWord())) { // 需走各分支逻辑 while (i + 1 < tokenLen) { TokenDescriptor nextToken = allTokens.get(i + 1); if("then".equalsIgnoreCase(nextToken.getRawWord())) { break; } whenExpressionCandidates.add(nextToken); ++i; } if(judgeWhenExpression(whenExpressionCandidates, suppliers)) { List<TokenDescriptor> resultCandidates = scrapeCaseWhenResultCandidates(allTokens, i + 1); return calcExpressionData(resultCandidates, suppliers); } // 直接进入下一轮迭代,then后面为空迭代 } if("else".equalsIgnoreCase(currentToken.getRawWord())) { List<TokenDescriptor> resultCandidates = scrapeCaseWhenResultCandidates(allTokens, i); return calcExpressionData(resultCandidates, suppliers); } } return null; } /** * 捞出所有的结果运算token列表 * * @param allTokens 全局token表 * @param start 偏移量 * @return 获取到的所有结果运算token */ private List<TokenDescriptor> scrapeCaseWhenResultCandidates(List<TokenDescriptor> allTokens, int start) { List<TokenDescriptor> resultCandidates = new ArrayList<>(); while (start + 1 < allTokens.size()) { TokenDescriptor nextToken = allTokens.get(start + 1); String word = nextToken.getRawWord(); if("when".equalsIgnoreCase(word) || "else".equalsIgnoreCase(word) || "end".equalsIgnoreCase(word)) { break; } resultCandidates.add(nextToken); ++start; } return resultCandidates; } /** * 判断when条件是否成立 * * @param operatorCandidates 可供运算的表达式token列表 * @param suppliers 原始字段取值来源 * @return true:符合该判定,false:判定失败 */ private boolean judgeWhenExpression(List<TokenDescriptor> operatorCandidates, Map<String, String> suppliers) { List<AndOrOperatorSupervisor> supervisors = partitionByPriority(operatorCandidates); boolean prevJudgeSuccess = false; for (AndOrOperatorSupervisor calc1 : supervisors) { Map<String, List<TokenDescriptor>> unitGroup = calc1.getUnitGroupTokens(); String leftValue = calcExpressionData(unitGroup.get("LEFT"), suppliers); String op = unitGroup.get("OP").get(0).getRawWord(); TokenTypeEnum resultType = getPriorDataTypeByTokenList(unitGroup.get("RIGHT")); boolean myJudgeSuccess; if("in".equals(op)) { myJudgeSuccess = checkExistsIn(leftValue, unitGroup.get("RIGHT"), resultType); } else if("notin".equals(op)) { myJudgeSuccess = !checkExistsIn(leftValue, unitGroup.get("RIGHT"), resultType); } else { String rightValue = calcExpressionData(unitGroup.get("RIGHT"), suppliers); myJudgeSuccess = checkCompareTrue(leftValue, op, rightValue, resultType); } TokenDescriptor prevType = calc1.getPrevType(); TokenDescriptor nextType = calc1.getNextType(); // 单条件判定 if(prevType == null && nextType == null) { return myJudgeSuccess; } if(nextType == null) { return myJudgeSuccess; } prevJudgeSuccess = myJudgeSuccess; if("and".equalsIgnoreCase(nextType.getRawWord())) { if(!myJudgeSuccess) { return false; } continue; } if("or".equalsIgnoreCase(nextType.getRawWord())) { if(myJudgeSuccess) { return true; } continue; } log.warn("解析到未知的next连接判定符:{}", nextType); throw new SyntaxException("语法解析错误"); } log.warn("未判定出结果,使用默认返回,请检查"); return false; } /** * 根据值信息推断运算数据类型 * * @param tokenList 结果列表(待运算) * @return 计算的数据类型,数字或字符串 */ private TokenTypeEnum getPriorDataTypeByTokenList(List<TokenDescriptor> tokenList) { for (TokenDescriptor token : tokenList) { if(token.getTokenType() == TokenTypeEnum.WORD_STRING) { return TokenTypeEnum.WORD_STRING; } } return TokenTypeEnum.WORD_NUMBER; } /** * 运算返回具体的 判定值 * * @param resultCandidates 结果表达式token列表 * @param suppliers 原始字段取值来源 * @return true:符合该判定,false:判定失败 */ private String calcExpressionData(List<TokenDescriptor> resultCandidates, Map<String, String> suppliers) { // 暂时假设结果中不再提供运算处理 TokenDescriptor first = resultCandidates.get(0); if(first.getTokenType() == TokenTypeEnum.WORD_NORMAL) { if("null".equalsIgnoreCase(first.getRawWord())) { return null; } return suppliers.get(first.getRawWord()); } return unwrapStringToken(first.getRawWord()); } /** * 判断给定值是否在列表中 * * @param aValue 要判定的值 * @param itemList 范围表 * @return true:成立, false:不在其中 */ private boolean checkExistsIn(String aValue, List<TokenDescriptor> itemList, TokenTypeEnum valueType) { if(aValue == null) { return false; } BigDecimal aValueNumber = null; for (TokenDescriptor tk1 : itemList) { if(valueType == TokenTypeEnum.WORD_NUMBER) { if(aValueNumber == null) { aValueNumber = new BigDecimal(aValue); } if(aValueNumber.compareTo( new BigDecimal(tk1.getRawWord())) == 0) { return true; } continue; } if(aValue.equals(unwrapStringToken(tk1.getRawWord()))) { return true; } } return false; } /** * 将字符串两边的引号去除,保持字符串属性 * * @param wrappedStr 含引号的字符串,如 'abc',"abc" * @return abc 无引号包裹的字符串 */ private String unwrapStringToken(String wrappedStr) { if(wrappedStr == null || wrappedStr.length() == 0) { return null; } char[] values = wrappedStr.toCharArray(); int i = 0; while (i < values.length - 1 && (values[i] == '"' || values[i] == '\'')) { i++; } int j = values.length - 1; while (j > 0 && (values[j] == '"' || values[j] == '\'')) { j--; } return new String(values, i, j - i + 1); } /** * 比较两个值ab是否基于op成立 * * @param aValue 左值 * @param op 比较运算符 * @param bValue 右值 * @param valueType 值类型, 主要是区分数字与字符 * @return 是否等式成立, true:成立, false:不成立 */ private boolean checkCompareTrue(String aValue, String op, String bValue, TokenTypeEnum valueType) { // 首先进行相生性判定 if("null".equals(bValue)) { bValue = null; } switch(op) { case "=": if(bValue == null) { return aValue == null; } return bValue.equals(aValue); case "!=": case "<>": if(bValue == null) { return aValue != null; } return !bValue.equals(aValue); } if(bValue == null) { log.warn("非null值不能用比较符号运算"); throw new SyntaxException("语法错误"); } // >=,<=,>,< 判定 int compareResult = compareTwoData(aValue, bValue, valueType); switch(op) { case ">": return compareResult > 0; case ">=": return compareResult >= 0; case "<=": return compareResult <= 0; case "<": return compareResult < 0; } throw new SyntaxException("未知的运算符"); } // 比较两个值大小ab private int compareTwoData(String aValue, String bValue, TokenTypeEnum tokenType) { bValue = unwrapStringToken(bValue); if(bValue == null) { // 按任意值大于null 规则处理 return aValue == null ? 0 : 1; } if(tokenType == TokenTypeEnum.WORD_NUMBER) { return new BigDecimal(aValue).compareTo( new BigDecimal(bValue)); } return aValue.compareTo(unwrapStringToken(bValue)); } // 将token重新分组,以便可以做原子运算 private List<AndOrOperatorSupervisor> partitionByPriority(List<TokenDescriptor> tokens) { // 1. 取左等式token列表 // 2. 取等式表达式 // 3. 取右等式token列表 // 4. 构建一个表达式,做最小分组 // 5. 检查是否有下一运算符,如有则必定为and|or|( // 6. 保存上一连接判定符,新开一个分组 // 7. 重复步骤1-6,直到取完所有token // 前置运算符,决定是否要运算本节点,以及结果的合并方式 // 比如 and, 则当前点必须参与运算,如果前节点结果为false,则直接返回false // 否则先计算本节点 TokenDescriptor preType = null; // 当前节点计算完成后,判断下一运算是否有必要触发 // 为and时则当前为true时必须触发,为or时当前为false触发 TokenDescriptor nextType = null; // key 为 left, op, right, 各value为细分tks Map<String, List<TokenDescriptor>> unitGroup = new HashMap<>(); String currentReadPos = "LEFT"; List<TokenDescriptor> smallGroupTokenList = new ArrayList<>(); // 以上为描述单个运算的字符,使用一个list就可以描述无括号的表达式了 List<AndOrOperatorSupervisor> bracketGroup = new ArrayList<>(); AndOrOperatorSupervisor supervisor = new AndOrOperatorSupervisor(null, unitGroup); bracketGroup.add(supervisor); for (int i = 0; i < tokens.size(); i++) { TokenDescriptor token = tokens.get(i); String word = token.getRawWord().toLowerCase(); TokenTypeEnum tokenType = token.getTokenType(); // 忽略分隔符,假设只有一级运算,忽略空格带来的复杂优先级问题 if(tokenType == TokenTypeEnum.CLAUSE_SEPARATOR) { continue; } // 字段直接判定 if(tokenType == TokenTypeEnum.COMPARE_OPERATOR && !",".equals(word)) { unitGroup.put("OP", Collections.singletonList(token)); currentReadPos = "RIGHT"; continue; } // is null, is not null 解析 if("is".equals(word)) { while (i + 1 < tokens.size()) { TokenDescriptor nextToken = tokens.get(i + 1); if("null".equalsIgnoreCase(nextToken.getRawWord())) { TokenDescriptor opToken = new TokenDescriptor("=", TokenTypeEnum.COMPARE_OPERATOR); unitGroup.put("OP", Collections.singletonList(opToken)); currentReadPos = "RIGHT"; List<TokenDescriptor> curTokenList = unitGroup.computeIfAbsent( currentReadPos, r -> new ArrayList<>()); curTokenList.add(nextToken); // 跳过1个token i += 1; break; } if("not".equalsIgnoreCase(nextToken.getRawWord())) { if(i + 2 >= tokens.size()) { throw new SyntaxException("语法错误3: is"); } nextToken = tokens.get(i + 2); if(!"null".equalsIgnoreCase(nextToken.getRawWord())) { throw new SyntaxException("语法错误4: is"); } TokenDescriptor opToken = new TokenDescriptor("!=", TokenTypeEnum.COMPARE_OPERATOR); unitGroup.put("OP", Collections.singletonList(opToken)); currentReadPos = "RIGHT"; List<TokenDescriptor> curTokenList = unitGroup.computeIfAbsent( currentReadPos, r -> new ArrayList<>()); curTokenList.add(nextToken); // 跳过2个token i += 2; break; } } continue; } // in (x,x,xx) 语法解析 if("in".equals(word)) { TokenDescriptor opToken = new TokenDescriptor("in", TokenTypeEnum.COMPARE_OPERATOR); unitGroup.put("OP", Collections.singletonList(opToken)); currentReadPos = "RIGHT"; List<TokenDescriptor> curTokenList = unitGroup.computeIfAbsent( currentReadPos, r -> new ArrayList<>()); i = parseInItems(tokens, curTokenList, i); continue; } // not in (x,xxx,xx) 语法解析 if("not".equals(word)) { if(i + 1 > tokens.size()) { throw new SyntaxException("语法错误:not"); } TokenDescriptor nextToken = tokens.get(i + 1); // 暂不支持 not exists 等语法 if(!"in".equalsIgnoreCase(nextToken.getRawWord())) { throw new SyntaxException("不支持的语法:not"); } TokenDescriptor opToken = new TokenDescriptor("notin", TokenTypeEnum.COMPARE_OPERATOR); unitGroup.put("OP", Collections.singletonList(opToken)); currentReadPos = "RIGHT"; List<TokenDescriptor> curTokenList = unitGroup.computeIfAbsent( currentReadPos, r -> new ArrayList<>()); i = parseInItems(tokens, curTokenList, i + 1); continue; } // 暂只解析一级,无括号情况 if("and".equals(word) || "or".equals(word)) { supervisor.setNextType(token); // 滚动到下一运算分支 unitGroup = new HashMap<>(); supervisor = new AndOrOperatorSupervisor(token, unitGroup); bracketGroup.add(supervisor); currentReadPos = "LEFT"; continue; } List<TokenDescriptor> curTokenList = unitGroup.computeIfAbsent( currentReadPos, r -> new ArrayList<>()); curTokenList.add(token); } return bracketGroup; } /** * 解析in中的所有元素到结果中 * * @param tokens 所有token * @param curTokenList 当前结果表 * @param start in 开始的地方 * @return in 语法结束位置 */ private int parseInItems(List<TokenDescriptor> tokens, List<TokenDescriptor> curTokenList, int start) { while (start + 1 < tokens.size()) { TokenDescriptor nextToken = tokens.get(++start); String nextWord = nextToken.getRawWord(); if("(".equals(nextWord) || ",".equals(nextWord)) { // in 开始 continue; } if(")".equals(nextWord)) { break; } curTokenList.add(nextToken); } return start; } /** * 最小运算单元描述符 */ private class AndOrOperatorSupervisor { // 前置运算符,决定是否要运算本节点,以及结果的合并方式 // 比如 and, 则当前点必须参与运算,如果前节点结果为false,则直接返回false // 否则先计算本节点 TokenDescriptor prevType; // 当前节点计算完成后,判断下一运算是否有必要触发 // 为and时则当前为true时必须触发,为or时当前为false触发 TokenDescriptor nextType; // key 为 left, op, right, 各value为细分tks Map<String, List<TokenDescriptor>> unitGroupTokens; public AndOrOperatorSupervisor(TokenDescriptor prevType, Map<String, List<TokenDescriptor>> unitGroupTokens) { this.prevType = prevType; this.unitGroupTokens = unitGroupTokens; } public void setNextType(TokenDescriptor nextType) { this.nextType = nextType; } public TokenDescriptor getPrevType() { return prevType; } public TokenDescriptor getNextType() { return nextType; } public Map<String, List<TokenDescriptor>> getUnitGroupTokens() { return unitGroupTokens; } @Override public String toString() { return StringUtils.join( unitGroupTokens.get("LEFT").stream() .map(TokenDescriptor::getRawWord) .collect(Collectors.toList()), ' ') + unitGroupTokens.get("OP").get(0).getRawWord() + StringUtils.join( unitGroupTokens.get("RIGHT").stream() .map(TokenDescriptor::getRawWord) .collect(Collectors.toList()), ' ') + ", prev=" + prevType + ", next=" + nextType ; } } }
每使用时,传入case..when..的语句构造出一个新的计算实例,然后调用 calcCaseWhenData(rawData), 带入已知参数信息,即可运算出最终的case..when..值。
为使处理简单起见,这里并没有深入各种逻辑嵌套处理,直接忽略掉括号的处理了。另外,对于数值类的运算也暂时被忽略,如 field1 > 1+1 这种运算,并不会计算出2来。这些东西,需要的同学,完全可以稍加完善,即可支持处理这些逻辑。
因 case when 的语法还是比较清晰的,所以我们只是做了顺序地读取,判定即得出结果。另外对于 case when 的单值判定并不支持,所以实现并不复杂。但这完全不影响我们理解整个语法处理的思想。相信需要的同学定能有所启发。
3. 表达式计算单元测试
以上仅实现代码,需要附加上各种场景测试,才算可以work的东西。主要就是针对种 and/or, in, is null 等的处理。如下:
import com.my.mvc.app.common.helper.CaseWhenElDataCalcHelper; import com.my.mvc.app.common.helper.SimpleSyntaxParser; import com.my.mvc.app.common.helper.parser.ParsedClauseAst; import lombok.extern.slf4j.Slf4j; import org.junit.Assert; import org.junit.Test; import java.util.HashMap; import java.util.Map; @Slf4j public class CaseWhenElDataCalcHelperTest { @Test public void testCaseWhenSimple1() { String condition; ParsedClauseAst parsedClause; CaseWhenElDataCalcHelper helper; Map<String, String> rawData; condition = "case \n" + "\twhen (kehu_phone is null or field1 != 'c') then m_phone \n" + "\telse kehu_phone\n" + "end"; parsedClause = SimpleSyntaxParser.parse(condition); helper = new CaseWhenElDataCalcHelper(parsedClause.getAst().get(0)); rawData = new HashMap<>(); rawData.put("kehu_phone", "kehu_phone_v1"); rawData.put("field1", "field1_v"); rawData.put("m_phone", "m_phone_v"); Assert.assertEquals("case..when..中解析字段信息不正确", 3, parsedClause.getIdMapping().size()); Assert.assertEquals("case..when..解析结果错误", rawData.get("m_phone"), helper.calcCaseWhenData(rawData)); condition = "case \n" + "\twhen (kehu_phone is null) then m_phone \n" + "\telse kehu_phone\n" + "end"; parsedClause = SimpleSyntaxParser.parse(condition); helper = new CaseWhenElDataCalcHelper(parsedClause.getAst().get(0)); rawData = new HashMap<>(); rawData.put("kehu_phone", "kehu_phone_v1"); rawData.put("field1", "field1_v"); rawData.put("m_phone", "m_phone_v"); Assert.assertEquals("case..when..中解析字段信息不正确", 2, parsedClause.getIdMapping().size()); Assert.assertEquals("case..when..解析结果错误", rawData.get("kehu_phone"), helper.calcCaseWhenData(rawData)); rawData.remove("kehu_phone"); Assert.assertEquals("case..when..解析结果错误", rawData.get("m_phone"), helper.calcCaseWhenData(rawData)); condition = " case \n" + " \twhen is_sx_emp='Y' then 'Y1' \n" + " \twhen is_sx_new_custom!='Y' then 'Y2' \n" + " \twhen is_sx_fort_promot_custom='Y' then 'Y3' \n" + " \twhen promotion_role_chn in ('10','11') and first_tenthousand_dt is not null then 'Y4' \n" + " \telse 'N' \n" + " end"; parsedClause = SimpleSyntaxParser.parse(condition); helper = new CaseWhenElDataCalcHelper(parsedClause.getAst().get(0)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "N"); rawData.put("is_sx_new_custom", "Y"); rawData.put("is_sx_fortune_promot_custom", "N"); rawData.put("promotion_role_chn", "10"); rawData.put("first_tenthousand_dt", "10"); Assert.assertEquals("case..when..中解析字段信息不正确", 5, parsedClause.getIdMapping().size()); Assert.assertEquals("case..when..in解析结果错误", "Y4", helper.calcCaseWhenData(rawData)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "N"); rawData.put("is_sx_new_custom", "Y"); rawData.put("is_sx_fortune_promot_custom", "N"); rawData.put("first_tenthousand_dt", "10"); rawData.put("promotion_role_chn", "9"); Assert.assertEquals("case..when..else解析结果错误", "N", helper.calcCaseWhenData(rawData)); rawData = new HashMap<>(); rawData.put("is_sx_new_custom", "Y"); rawData.put("is_sx_fortune_promot_custom", "N"); rawData.put("first_tenthousand_dt", "10"); rawData.put("promotion_role_chn", "9"); rawData.put("is_sx_emp", "Y"); Assert.assertEquals("case..when..=解析结果错误", "Y1", helper.calcCaseWhenData(rawData)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "N"); rawData.put("is_sx_new_custom", "N"); rawData.put("is_sx_fortune_promot_custom", "N"); rawData.put("first_tenthousand_dt", "10"); rawData.put("promotion_role_chn", "9"); Assert.assertEquals("case..when..!=解析结果错误", "Y2", helper.calcCaseWhenData(rawData)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "N"); rawData.put("is_sx_new_custom", "Y"); rawData.put("is_sx_fortune_promot_custom", "N"); // rawData.put("first_tenthousand_dt", "10"); rawData.put("promotion_role_chn", "9"); Assert.assertEquals("case..when..in+and+null解析结果错误", "N", helper.calcCaseWhenData(rawData)); condition = " case \n" + " \twhen is_sx_emp='Y' then 'Y1' \n" + " \twhen or_emp != null or or_emp2 > 3 then 'Y2_OR' \n" + " \twhen and_emp != null and and_emp2 > 3 or or_tmp3 <= 10 then 'Y3_OR' \n" + " \twhen promotion_role_chn not in ('10','11') and first_tenthousand_dt is not null then 'Y4' \n" + " \twhen promotion_role_chn not in ('10') then 'Y5_NOTIN' \n" + " \telse 'N_ELSE' \n" + " end"; parsedClause = SimpleSyntaxParser.parse(condition); helper = new CaseWhenElDataCalcHelper(parsedClause.getAst().get(0)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "N"); rawData.put("or_emp", "Y"); Assert.assertEquals("case..when..中解析字段信息不正确", 8, parsedClause.getIdMapping().size()); Assert.assertEquals("case..when..in解析结果错误", "Y2_OR", helper.calcCaseWhenData(rawData)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "N"); // rawData.put("or_emp", "Y"); rawData.put("or_emp2", "2"); Assert.assertEquals("case..when..or>2解析结果错误", "Y5_NOTIN", helper.calcCaseWhenData(rawData)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "N"); // rawData.put("or_emp", "Y"); rawData.put("or_emp2", "2"); rawData.put("promotion_role_chn", "10"); Assert.assertEquals("case..when..notin解析结果错误", "N_ELSE", helper.calcCaseWhenData(rawData)); condition = " case \n" + " \twhen (is_sx_emp='Y' or a_field=3) then 'Y1' \n" + " \telse 'N_ELSE' \n" + " end"; parsedClause = SimpleSyntaxParser.parse(condition); helper = new CaseWhenElDataCalcHelper(parsedClause.getAst().get(0)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "N"); rawData.put("or_emp", "Y"); Assert.assertEquals("case..when..中解析字段信息不正确", 2, parsedClause.getIdMapping().size()); Assert.assertEquals("case..when..()号解析结果错误", "N_ELSE", helper.calcCaseWhenData(rawData)); rawData = new HashMap<>(); rawData.put("is_sx_emp", "Y"); rawData.put("or_emp", "Y"); Assert.assertEquals("case..when..中解析字段信息不正确", 2, parsedClause.getIdMapping().size()); Assert.assertEquals("case..when..()号解析结果错误2", "Y1", helper.calcCaseWhenData(rawData)); } }
如果有更多场景,我们只需添加测试,然后完善相应逻辑即可。这里所有的测试,都可以基于sql协议进行,如有空缺则应弥补相应功能,而非要求用户按自己的标准来,毕竟标准是个好东西。
4. 更多表达式计算
实际上,对表达式计算这东西,我们也许不一定非要自己去实现。毕竟太费力。有开源产品支持的,比如:aviator: https://www.oschina.net/p/aviator?hmsr=aladdin1e1 https://www.jianshu.com/p/02403dd1f4c4
如果该语法不支持,则可以先转换成支持的语法,再使用其引擎计算即可。
本质上,我们都是在做翻译工作!
标签:解析器,case,..,when,语法,rawData,put,new 来源: https://www.cnblogs.com/yougewe/p/14052362.html