【JSqlParser】sql解析器使用案例
【一】需求描述
项目中支持文件导入指标的业务限定（也就是where条件），并且可以指定是普通模式还是代码模式，如果是普通模式就要把where解析成一个个条件语句，并转换成嵌套的组件对象
【二】组件对象
@Data
@Schema(description = "业务限定词")
public class IndEngineSqlCondition implements Serializable {
private static final long serialVersionUID = -1L;
/**
* and/or
*/
@Schema(description = "and/Or")
private String type;
@Schema(description = "条件项")
private ConditionField conditionField;
@Schema(description = "子项")
private List<IndEngineSqlCondition> children;
@Schema(description = "扩展项")
private Map<String, String> ext;
@Schema(description = "top信息对象")
private TopInfo topInfo;
private Map<String, IndEngineColumn> columnMap = Maps.newHashMap();
@Data
@Schema(description = "top信息对象")
public static class TopInfo implements Serializable {
private static final long serialVersionUID = 5820012879123811247L;
@Schema(description = "排序")
private String topSort;
@Schema(description = "限量值")
private Integer topLimitNum;
}
@Data
@Schema(description = "条件项对象")
public static class ConditionField implements Serializable {
private static final long serialVersionUID = 5820012879121811247L;
/**
* @see CfTypeEnum
*/
@Schema(description = "条件项对象类型:00(事实表);01(维度表);02(层级的维表);03(衍生的维表);" +
"11(普通维度);12(维度属性);13(衍生维度);14(度量属性);" +
"20(指标值);21(业务日期);22(指标编码);23(指标版本)")
private String cfType;
@Schema(description = "表别名")
private String aliasNm;
@Schema(description = "表名")
private String tableName;
@Schema(description = "字段ID,配合 cfType 属性使用")
private String fieldId;
@Schema(description = "字段名,映射数据库字段名称")
private String fieldName;
@Schema(description = "获取日期值的函数")
private String fieldDateFunc;
@Schema(description = "值1")
private String fieldValue1;
@Schema(description = "值2")
private String fieldValue2;
@Schema(description = "日期时分秒")
private List<String> fieldTimeValueRang;
@Schema(description = "数据类型:VARCHAR等")
@Deprecated
private String fieldType;
@Schema(description = "关联模型字段的类型")
private Integer propertyType;
@Schema(description = "数据类型:字符类型、数字类型、日期等")
private Integer dataCategory;
@Schema(description = "日期类型")
private String datePlaceholderFormat;
@Schema(description = "操作符")
private String symbol;
@Schema(description = "字段项")
private ColumnInfo columnInfo;
@Schema(description = "扩展项")
private Map<String, String> ext = new HashMap<>();
@Schema(description = "是否生效,慎用")
private boolean effect = true;
}
@Data
@Schema(description = "字段对象")
public static class ColumnInfo implements Serializable {
@Schema(description = "字段类型：0-度量，1-维度，6-维度属性")
private String propertyType;
@Schema(description = "关联表名称")
private String tableName;
@Schema(description = "关联维度字段名称")
private String linkColumnEnName;
@Schema(description = "关联维度id")
private String dimensionId;
@Schema(description = "父级字段名")
private String fieldParentName;
}
}
【三】解析逻辑
（1）组件对象是分层的，每层有独立的且或逻辑，每层要用括号包围起来
（2）需要判断and和or的逻辑，如果有括号把and或or包围起来了，需要判断是否创建子级children
（3）in和not in，like和not like，between，is null和is not null，这几种语句要单独处理
【四】代码实现SqlConditionUtil
（1）传入参数，构建一个完整的可以解析的sql
1-whereSql：where条件语句，语句中的字段都是中文名称
2-columnMap：字段中文名称的Map，用来获取字段的详情，例如字段数据的日期格式
public static void parseSql2Condition (String whereSql, Map<String, IndColumn> columnMap, IndEngineSqlCondition sqlCondition) {
if (ObjectUtil.isEmpty(whereSql)) {
return;
}
// 初始化
sqlCondition.setChildren(Lists.newArrayList());
// (
// a.ORG = '111'
// and a.D_D_a_d_001 >= '2025-07-16 00:00:00'
// and ((a.D_D_a_b_004 > '0' and a.D_D_a_b_004 < '100') or (a.D_D_a_b_004 > '300' and a.D_D_a_b_004 < '500'))
// and a.D_D_f_a_005 is not null
// and a.D_D_d_y_007 >= '2025-07-08'
// )
whereSql = StrUtil.format("SELECT * FROM a WHERE {}",whereSql);
// 解析sql
Statement statement = null;
try {
statement = CCJSqlParserUtil.parse(whereSql);
} catch (JSQLParserException exception) {
log.info("sql解析失败：{}",exception.getMessage());
throw new YTRuntimeException("sql解析失败");
}
// 提取SELECT语句体
if (statement instanceof Select) {
Select select = (Select) statement;
PlainSelect plainSelect = (PlainSelect) select.getSelectBody();
Expression whereExpression = plainSelect.getWhere();
if (whereExpression != null) {
System.out.println("WHERE条件解析结果:");
Expression unwrappedExpr = unwrapParenthesis(whereExpression);
sqlCondition = parseExpression(unwrappedExpr, columnMap, sqlCondition);
}
}
// 判断sql是否符合规范
// 对sql进行重新组装，装填SqlCondition
System.out.println("解析成功:"+sqlCondition.toString());
}
（2）递归移除所有外层括号
否则对象就是Parenthesis类型，不能转成其他类型
/**
* 递归移除所有外层括号
*/
private static Expression unwrapParenthesis(Expression expr) {
if (expr instanceof Parenthesis) {
Parenthesis parenthesis = (Parenthesis) expr;
// 递归处理括号内的表达式，处理多层嵌套
return unwrapParenthesis(parenthesis.getExpression());
}
return expr;
}
（3）递归解析表达式，并构建条件树
// 解析表达式并构建条件树
private static IndEngineSqlCondition parseExpression(Expression expr,Map<String, IndColumn> columnMap,IndEngineSqlCondition sqlCondition) {
// 先处理可能存在的括号
if (expr instanceof AndExpression) {
// 处理and逻辑
AndExpression andExpr = (AndExpression) expr;
sqlCondition.setType("and");
sqlCondition = parseExpression(andExpr.getRightExpression(),columnMap,sqlCondition);
sqlCondition = parseExpression(andExpr.getLeftExpression(),columnMap,sqlCondition);
return sqlCondition;
} else if (expr instanceof OrExpression) {
// 处理or逻辑
OrExpression orExpr = (OrExpression) expr;
sqlCondition.setType("or");
sqlCondition = parseExpression(orExpr.getRightExpression(),columnMap,sqlCondition);
sqlCondition = parseExpression(orExpr.getLeftExpression(),columnMap,sqlCondition);
return sqlCondition;
} else if (expr instanceof Parenthesis) {
// 处理括号嵌套
Parenthesis parenthesis = (Parenthesis) expr;
String createNewLevelType = checkCreateNewLevel(parenthesis);
if (ObjectUtil.isNotEmpty(createNewLevelType)) {
// 需要创建新的子级分层，实现嵌套内容
Expression expression = unwrapParenthesis(parenthesis);
IndEngineSqlCondition childrenSqlCondition = new IndEngineSqlCondition();
childrenSqlCondition.setChildren(Lists.newArrayList());
childrenSqlCondition.setType(createNewLevelType);// 且或关系
childrenSqlCondition = parseExpression(expression,columnMap,childrenSqlCondition);
sqlCondition.getChildren().add(0,childrenSqlCondition);
} else {
// 不需要创建新的子级分层
Expression expression = unwrapParenthesis(parenthesis);
sqlCondition = parseExpression(expression,columnMap,sqlCondition);
}
return sqlCondition;
}
else if (expr instanceof Between) {
// 单独处理Between表达式
sqlCondition.getChildren().add(0,parseBetweenExpression((Between) expr, columnMap));
return sqlCondition;
}
else if (expr instanceof InExpression) {
// 单独处理In表达式
sqlCondition.getChildren().add(0,parseInExpression((InExpression) expr, columnMap));
return sqlCondition;
}
else if (expr instanceof LikeExpression) {
// 单独处理Like表达式
sqlCondition.getChildren().add(0,parseLikeExpression((LikeExpression) expr, columnMap));
return sqlCondition;
}
else if (expr instanceof IsNullExpression) {
// 单独处理Null判断表达式
sqlCondition.getChildren().add(0,parseNullExpression((IsNullExpression) expr, columnMap));
return sqlCondition;
}
else {
// 处理普通计算符号逻辑
// 单个条件解析完毕，添加到child集合
IndEngineSqlCondition childrenSqlCondition = parseBinaryExpression((BinaryExpression) expr, columnMap);
sqlCondition.getChildren().add(0,childrenSqlCondition);
return sqlCondition;
}
// 处理其他类型的表达式
//ConditionNode node = new ConditionNode("CONDITION");
//node.setField("unknown");
//node.setOperator("=");
//node.setValue(expr.toString());
//return null;
}
（4）判断组件是否新建子级分层
/**
* 判断组件是否新建子级分层
* @param expr
* @return
*/
private static String checkCreateNewLevel (Expression expr) {
String newLevelType = "";
if (expr instanceof Parenthesis) {
Expression expression = unwrapParenthesis(expr);
if (expression instanceof OrExpression) {
newLevelType = "or";
} else if (expression instanceof AndExpression) {
newLevelType = "and";
}
}
return newLevelType;
}
（5）专门解析Between表达式
/**
* 专门解析Between表达式（新增方法）
*/
private static IndEngineSqlCondition parseBetweenExpression(Between between,Map<String, IndColumn> colMap) {
IndEngineSqlCondition sqlCondition = new IndEngineSqlCondition();
IndEngineSqlCondition.ConditionField conditionField = new IndEngineSqlCondition.ConditionField();
// 判断动态时间还是动态周期
//String statisticalCycle = StrUtil.split(between.getBetweenExpressionStart().toString(), "_START").get(0).replace("#[", "").replace("'", "");
//statisticalCycle = DynamicDateUtil.buildDynamicDatePlaceHolder(statisticalCycle);
//StatisticalCycleEnum statisticalCycleEnum = StatisticalCycleEnum.getInstance(statisticalCycle);
//String symbol = ObjectUtil.equals(statisticalCycleEnum.getType(),1)? SymbolEnum.DTIME.getCode():SymbolEnum.CYCLE.getCode();
//conditionField.setSymbol(symbol);
Tuple3<String,List<String>,String> placeHolderAndTimeRange = DynamicDateUtil.parseDynamicDatePlaceHolderAndTimeRange(between.getBetweenExpressionStart().toString());
// 动态时间占位符
String placeHolder = placeHolderAndTimeRange.getV1();
StatisticalCycleEnum statisticalCycleEnum = StatisticalCycleEnum.getInstance(placeHolder);
String symbol = ObjectUtil.equals(statisticalCycleEnum.getType(),1)? SymbolEnum.DTIME.getCode():SymbolEnum.CYCLE.getCode();
conditionField.setSymbol(symbol);
conditionField.setFieldDateFunc(statisticalCycleEnum.getId().toString());
conditionField.setFieldValue1(placeHolder);
// 动态时间的时间范围
List<String> timeRange = placeHolderAndTimeRange.getV2();
conditionField.setFieldTimeValueRang(timeRange);
// 获取字段表达式
String colName = "";
Expression leftExpr = unwrapParenthesis(between.getLeftExpression());
if (leftExpr instanceof Column) {
colName = ((Column) leftExpr).getColumnName();
} else if (leftExpr instanceof Function) {
Function function = (Function) leftExpr;
String functionName = function.getName();
if (!function.getParameters().getExpressions().isEmpty()) {
Expression paramExpr = function.getParameters().getExpressions().get(0);
Expression unwrappedParam = unwrapParenthesis(paramExpr);
if (unwrappedParam instanceof Column) {
colName = functionName + "(" + ((Column) unwrappedParam).getColumnName() + ")";
}
}
} else {
colName = leftExpr.toString();
}
// 获取值范围
//String value = getExpressionValue(unwrapParenthesis(between.getBetweenExpressionStart())) +
// " AND " +
// getExpressionValue(unwrapParenthesis(between.getBetweenExpressionEnd()));
//conditionField.setFieldValue1(unwrapParenthesis(between.getBetweenExpressionStart()).toString().replace("'",""));
//conditionField.setFieldValue2(unwrapParenthesis(between.getBetweenExpressionEnd()).toString().replace("'",""));
// 空值判断没有具体值，设置为null
colName = colName.toUpperCase();
conditionField.setFieldId(colMap.get(colName).getId().toString());
conditionField.setFieldName(colMap.get(colName).getColumnEnName());
conditionField.setDataCategory(colMap.get(colName).getDataCategory());
conditionField.setFieldType(colMap.get(colName).getDataType());
conditionField.setTableName(colMap.get(colName).getTableName());
conditionField.setDatePlaceholderFormat(colMap.get(colName).getDatePlaceholderFormat());
conditionField.setCfType(colMap.get(colName).getCfType());
conditionField.setPropertyType(colMap.get(colName).getPropertyType());
SqlCondition.ColumnInfo columnInfo = new SqlCondition.ColumnInfo();
columnInfo.setPropertyType(colMap.get(colName).getPropertyType().toString());
columnInfo.setFieldParentName(colMap.get(colName).getFieldParentName());
columnInfo.setLinkColumnEnName(colMap.get(colName).getLinkColumnEnName());
columnInfo.setTableName(colMap.get(colName).getTableName());
columnInfo.setDimensionId(colMap.get(colName).getDimensionId());
conditionField.setColumnInfo(columnInfo);
sqlCondition.setConditionField(conditionField);
return sqlCondition;
}
（6）解析IS NULL和IS NOT NULL表达式
/**
* 解析IS NULL和IS NOT NULL表达式
*/
private static IndEngineSqlCondition parseNullExpression(IsNullExpression nullExpr,Map<String, IndColumn> colMap) {
IndEngineSqlCondition sqlCondition = new IndEngineSqlCondition();
IndEngineSqlCondition.ConditionField conditionField = new IndEngineSqlCondition.ConditionField();
// 判断是IS NULL还是IS NOT NULL
if (nullExpr.isNot()) {
conditionField.setSymbol(SymbolEnum.NNVL.getCode());
} else {
conditionField.setSymbol(SymbolEnum.NVL.getCode());
}
// 获取字段表达式
Expression leftExpr = unwrapParenthesis(nullExpr.getLeftExpression());
String colName = "";
if (leftExpr instanceof Column) {
colName = ((Column) leftExpr).getColumnName();
} else if (leftExpr instanceof Function) {
Function function = (Function) leftExpr;
String functionName = function.getName();
if (!function.getParameters().getExpressions().isEmpty()) {
Expression paramExpr = function.getParameters().getExpressions().get(0);
Expression unwrappedParam = unwrapParenthesis(paramExpr);
if (unwrappedParam instanceof Column) {
colName = functionName + "(" + ((Column) unwrappedParam).getColumnName() + ")";
}
}
} else {
colName = leftExpr.toString();
}
// 空值判断没有具体值，设置为null
colName = colName.toUpperCase();
conditionField.setFieldId(colMap.get(colName).getId().toString());
conditionField.setFieldName(colMap.get(colName).getColumnEnName());
conditionField.setDataCategory(colMap.get(colName).getDataCategory());
conditionField.setFieldType(colMap.get(colName).getDataType());
conditionField.setTableName(colMap.get(colName).getTableName());
conditionField.setDatePlaceholderFormat(colMap.get(colName).getDatePlaceholderFormat());
conditionField.setCfType(colMap.get(colName).getCfType());
conditionField.setPropertyType(colMap.get(colName).getPropertyType());
SqlCondition.ColumnInfo columnInfo = new SqlCondition.ColumnInfo();
columnInfo.setPropertyType(colMap.get(colName).getPropertyType().toString());
columnInfo.setFieldParentName(colMap.get(colName).getFieldParentName());
columnInfo.setLinkColumnEnName(colMap.get(colName).getLinkColumnEnName());
columnInfo.setTableName(colMap.get(colName).getTableName());
columnInfo.setDimensionId(colMap.get(colName).getDimensionId());
conditionField.setColumnInfo(columnInfo);
sqlCondition.setConditionField(conditionField);
return sqlCondition;
}
（7）解析IS NULL和IS NOT NULL表达式
/**
* 解析IS NULL和IS NOT NULL表达式
*/
private static IndEngineSqlCondition parseInExpression(InExpression inExpr,Map<String, IndColumn> colMap) {
IndEngineSqlCondition sqlCondition = new IndEngineSqlCondition();
IndEngineSqlCondition.ConditionField conditionField = new IndEngineSqlCondition.ConditionField();
// 判断是IS NULL还是IS NOT NULL
if (inExpr.isNot()) {
conditionField.setSymbol(SymbolEnum.NOTIN.getCode());
} else {
conditionField.setSymbol(SymbolEnum.IN.getCode());
}
// 获取字段表达式
Expression leftExpr = unwrapParenthesis(inExpr.getLeftExpression());
String colName = "";
if (leftExpr instanceof Column) {
colName = ((Column) leftExpr).getColumnName();
} else if (leftExpr instanceof Function) {
Function function = (Function) leftExpr;
String functionName = function.getName();
if (!function.getParameters().getExpressions().isEmpty()) {
Expression paramExpr = function.getParameters().getExpressions().get(0);
Expression unwrappedParam = unwrapParenthesis(paramExpr);
if (unwrappedParam instanceof Column) {
colName = functionName + "(" + ((Column) unwrappedParam).getColumnName() + ")";
}
}
} else {
colName = leftExpr.toString();
}
Expression rightExpression = inExpr.getRightExpression();
String rightValue = rightExpression.toString().replace("'", "").replace(",", ";").replace("(","").replace(")","");
// 空值判断没有具体值，设置为null
colName = colName.toUpperCase();
conditionField.setFieldId(colMap.get(colName).getId().toString());
conditionField.setFieldName(colMap.get(colName).getColumnEnName());
conditionField.setDataCategory(colMap.get(colName).getDataCategory());
conditionField.setFieldType(colMap.get(colName).getDataType());
conditionField.setTableName(colMap.get(colName).getTableName());
conditionField.setDatePlaceholderFormat(colMap.get(colName).getDatePlaceholderFormat());
conditionField.setCfType(colMap.get(colName).getCfType());
conditionField.setFieldValue1(rightValue);
conditionField.setPropertyType(colMap.get(colName).getPropertyType());
SqlCondition.ColumnInfo columnInfo = new SqlCondition.ColumnInfo();
columnInfo.setPropertyType(colMap.get(colName).getPropertyType().toString());
columnInfo.setFieldParentName(colMap.get(colName).getFieldParentName());
columnInfo.setLinkColumnEnName(colMap.get(colName).getLinkColumnEnName());
columnInfo.setTableName(colMap.get(colName).getTableName());
columnInfo.setDimensionId(colMap.get(colName).getDimensionId());
conditionField.setColumnInfo(columnInfo);
sqlCondition.setConditionField(conditionField);
return sqlCondition;
}
（8）解析LIKE和NOT LIKE表达式
/**
* 解析LIKE和NOT LIKE表达式
*/
private static IndEngineSqlCondition parseLikeExpression(LikeExpression likeExpr,Map<String, IndColumn> colMap) {
IndEngineSqlCondition sqlCondition = new IndEngineSqlCondition();
IndEngineSqlCondition.ConditionField conditionField = new IndEngineSqlCondition.ConditionField();
// 判断是IS NULL还是IS NOT NULL
if (likeExpr.isNot()) {
conditionField.setSymbol(SymbolEnum.NOLIKE.getCode());
} else {
conditionField.setSymbol(SymbolEnum.LIKE.getCode());
}
// 获取字段表达式
Expression leftExpr = unwrapParenthesis(likeExpr.getLeftExpression());
String colName = "";
if (leftExpr instanceof Column) {
colName = ((Column) leftExpr).getColumnName();
} else if (leftExpr instanceof Function) {
Function function = (Function) leftExpr;
String functionName = function.getName();
if (!function.getParameters().getExpressions().isEmpty()) {
Expression paramExpr = function.getParameters().getExpressions().get(0);
Expression unwrappedParam = unwrapParenthesis(paramExpr);
if (unwrappedParam instanceof Column) {
colName = functionName + "(" + ((Column) unwrappedParam).getColumnName() + ")";
}
}
} else {
colName = leftExpr.toString();
}
Expression rightExpression = likeExpr.getRightExpression();
String rightValue = rightExpression.toString().replace("'", "").replace("%", "").replace("(","").replace(")","");
// 空值判断没有具体值，设置为null
colName = colName.toUpperCase();
conditionField.setFieldId(colMap.get(colName).getId().toString());
conditionField.setFieldName(colMap.get(colName).getColumnEnName());
conditionField.setDataCategory(colMap.get(colName).getDataCategory());
conditionField.setFieldType(colMap.get(colName).getDataType());
conditionField.setTableName(colMap.get(colName).getTableName());
conditionField.setDatePlaceholderFormat(colMap.get(colName).getDatePlaceholderFormat());
conditionField.setCfType(colMap.get(colName).getCfType());
conditionField.setFieldValue1(rightValue);
conditionField.setPropertyType(colMap.get(colName).getPropertyType());
SqlCondition.ColumnInfo columnInfo = new SqlCondition.ColumnInfo();
columnInfo.setPropertyType(colMap.get(colName).getPropertyType().toString());
columnInfo.setFieldParentName(colMap.get(colName).getFieldParentName());
columnInfo.setLinkColumnEnName(colMap.get(colName).getLinkColumnEnName());
columnInfo.setTableName(colMap.get(colName).getTableName());
columnInfo.setDimensionId(colMap.get(colName).getDimensionId());
conditionField.setColumnInfo(columnInfo);
sqlCondition.setConditionField(conditionField);
return sqlCondition;
}
（9）解析二元表达式，提取字段、运算符和值
// 解析二元表达式，提取字段、运算符和值
private static IndEngineSqlCondition parseBinaryExpression(BinaryExpression expr,Map<String, IndColumn> colMap) {
IndEngineSqlCondition sqlCondition = new IndEngineSqlCondition();
IndEngineSqlCondition.ConditionField conditionField = new IndEngineSqlCondition.ConditionField();
// 获取运算符
String operator = getOperatorSymbol(expr);
conditionField.setSymbol(operator);
// 提取字段和值，先处理可能的括号
Expression leftExpr = unwrapParenthesis(expr.getLeftExpression());
Expression rightExpr = unwrapParenthesis(expr.getRightExpression());
String colName = "";
String rightValue = "";
// 通常左表达式是字段，右表达式是值
if (leftExpr instanceof Column) {
colName = ((Column) leftExpr).getColumnName();
rightValue = getExpressionValue(rightExpr);
}
// 处理特殊情况，如值在左边的情况
else if (rightExpr instanceof Column) {
colName = ((Column) rightExpr).getColumnName();
rightValue = getExpressionValue(leftExpr);
}
// 处理函数表达式，如DATE(create_time) = '2023-01-01'
else if (leftExpr instanceof Function) {
Function function = (Function) leftExpr;
String functionName = function.getName();
if (!function.getParameters().getExpressions().isEmpty()) {
Expression paramExpr = function.getParameters().getExpressions().get(0);
// 处理参数可能带有的括号
Expression unwrappedParam = unwrapParenthesis(paramExpr);
if (unwrappedParam instanceof Column) {
colName = functionName + "(" + ((Column) unwrappedParam).getColumnName() + ")";
rightValue = getExpressionValue(rightExpr);
}
}
} else {
colName = leftExpr.toString();
rightValue = rightExpr.toString();
}
rightValue = rightValue.replace("'", "");
colName = colName.toUpperCase();
conditionField.setFieldValue1(rightValue);
conditionField.setFieldId(colMap.get(colName).getId().toString());
conditionField.setFieldName(colMap.get(colName).getColumnEnName());
conditionField.setDataCategory(colMap.get(colName).getDataCategory());
conditionField.setFieldType(colMap.get(colName).getDataType());
conditionField.setTableName(colMap.get(colName).getTableName());
conditionField.setDatePlaceholderFormat(colMap.get(colName).getDatePlaceholderFormat());
conditionField.setCfType(colMap.get(colName).getCfType());
conditionField.setPropertyType(colMap.get(colName).getPropertyType());
SqlCondition.ColumnInfo columnInfo = new SqlCondition.ColumnInfo();
columnInfo.setPropertyType(colMap.get(colName).getPropertyType().toString());
columnInfo.setFieldParentName(colMap.get(colName).getFieldParentName());
columnInfo.setLinkColumnEnName(colMap.get(colName).getLinkColumnEnName());
columnInfo.setTableName(colMap.get(colName).getTableName());
columnInfo.setDimensionId(colMap.get(colName).getDimensionId());
conditionField.setColumnInfo(columnInfo);
sqlCondition.setConditionField(conditionField);
return sqlCondition;
}
（10）获取表达式的值（处理常量、字符串等）
// 获取表达式的值（处理常量、字符串等）
private static String getExpressionValue(Expression expr) {
String expressionValue = "";
if (expr instanceof Constant) {
//Object value = ((Constant) expr).getValue();
//return value != null ? value.toString() : "NULL";
} else if (expr instanceof StringValue) {
expressionValue = "'" + ((StringValue) expr).getValue() + "'";
} else if (expr instanceof LongValue) {
expressionValue = String.valueOf(((LongValue) expr).getValue());
} else if (expr instanceof DoubleValue) {
expressionValue = String.valueOf(((DoubleValue) expr).getValue());
} else {
expressionValue = expr.toString();
}
return expressionValue;
}
（11）获取运算符的符号表示
这里封装了枚举，可以直接替换常量
// 获取运算符的符号表示
private static String getOperatorSymbol(BinaryExpression expr) {
if (expr instanceof EqualsTo) {
return SymbolEnum.EQ.getCode();
} else if (expr instanceof NotEqualsTo) {
return SymbolEnum.NEQ.getCode();
} else if (expr instanceof GreaterThan) {
return SymbolEnum.GT.getCode();
} else if (expr instanceof GreaterThanEquals) {
return SymbolEnum.GTE.getCode();
} else if (expr instanceof MinorThan) {
return SymbolEnum.LT.getCode();
} else if (expr instanceof MinorThanEquals) {
return SymbolEnum.LTE.getCode();
} else {
return expr.getStringExpression();
}
}