Java SQLExpr类代码示例

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
@Override
protected Column getColumn(SQLExpr expr) {
    Map<String, String> aliasMap = getAliasMap();
    if (aliasMap == null) {
        return null;
    }

    if (expr instanceof SQLPropertyExpr) {
        return getColumnByExpr((SQLPropertyExpr) expr, aliasMap);
    }

    if (expr instanceof SQLIdentifierExpr) {
        return getColumnByExpr((SQLIdentifierExpr) expr, aliasMap);
    }

    if (expr instanceof SQLBetweenExpr) {
        return getColumnByExpr((SQLBetweenExpr) expr, aliasMap);
    }
    return null;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
public boolean contains(SQLTableSource tableSource, SQLExpr condition) {
    if (right.equals(tableSource)) {
        if (this.condition == condition) {
            return true;
        }

        return this.condition != null && this.condition.equals(condition);
    }

    if (left instanceof SQLJoinTableSource) {
        SQLJoinTableSource joinLeft = (SQLJoinTableSource) left;

        if (tableSource instanceof SQLJoinTableSource) {
            SQLJoinTableSource join = (SQLJoinTableSource) tableSource;

            if (join.right.equals(right) && this.condition.equals(condition) && joinLeft.right.equals(join.left)) {
                return true;
            }
        }

        return joinLeft.contains(tableSource, condition);
    }

    return false;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
public Object eval(SQLEvalVisitor visitor, SQLMethodInvokeExpr x) {
    if (x.getParameters().size() != 1) {
        return SQLEvalVisitor.EVAL_ERROR;
    }

    SQLExpr param0 = x.getParameters().get(0);
    param0.accept(visitor);

    Object param0Value = param0.getAttributes().get(EVAL_VALUE);
    if (param0Value == null) {
        return SQLEvalVisitor.EVAL_ERROR;
    }

    String strValue = param0Value.toString();

    int result = strValue.length();
    return result;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
@Test
public void stringAndNumberEqualConditionWithoutProperty() throws SqlParseException {
    SQLExpr sqlExpr = queryToExpr("select * from xxx/locs where 'a' = 1");
    Select select = parser.parseSelect((SQLQueryExpr) sqlExpr);
    List<Where> wheres = select.getWhere().getWheres();
    Assert.assertTrue(wheres.size() == 1);
    Condition condition = (Condition) wheres.get(0);
    Assert.assertTrue(condition.getValue() instanceof ScriptFilter);
    ScriptFilter sf = (ScriptFilter) condition.getValue();
    Assert.assertEquals(sf.getScript(), "'a' == 1");
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
@Override
public SQLExpr toExpression() {
    SQLCastExpr cast = new SQLCastExpr();
    cast.setExpr(args.get(0).toExpression());
    SQLDataTypeImpl dataType = new SQLDataTypeImpl("DATETIME");
    if (decimals != Item.NOT_FIXED_DEC) {
        dataType.addArgument(new SQLIntegerExpr(decimals));
    }
    cast.setDataType(dataType);
    return cast;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
private static boolean columnInExpr(SQLExpr sqlExpr, String colName) throws SQLNonTransientException {
    String column;
    if (sqlExpr instanceof SQLIdentifierExpr) {
        column = StringUtil.removeBackQuote(((SQLIdentifierExpr) sqlExpr).getName()).toUpperCase();
    } else if (sqlExpr instanceof SQLPropertyExpr) {
        column = StringUtil.removeBackQuote(((SQLPropertyExpr) sqlExpr).getName()).toUpperCase();
    } else {
        throw new SQLNonTransientException("Unhandled SQL AST node type encountered: " + sqlExpr.getClass());
    }

    return column.equals(colName.toUpperCase());
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
private static boolean isMycatSeq(String stmt, SchemaConfig schema)
  {
      if(pattern.matcher(stmt).find()) {
	return true;
}
      SQLStatementParser parser =new MySqlStatementParser(stmt);
      MySqlInsertStatement statement = (MySqlInsertStatement) parser.parseStatement();
      String tableName=   statement.getTableName().getSimpleName();
      TableConfig tableConfig= schema.getTables().get(tableName.toUpperCase());
      if(tableConfig==null) {
	return false;
}
      if(tableConfig.isAutoIncrement())
      {
          boolean isHasIdInSql=false;
          String primaryKey = tableConfig.getPrimaryKey();
          List<SQLExpr> columns = statement.getColumns();
          for (SQLExpr column : columns)
          {
              String columnName = column.toString();
              if(primaryKey.equalsIgnoreCase(columnName))
              {
                  isHasIdInSql = true;
                  break;
              }
          }
          if(!isHasIdInSql) {
		return true;
	}
      }


      return false;
  }
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
@Override
public SQLExpr toExpression() {
    Item arg0 = args.get(0);
    SQLAggregateExpr aggregate = new SQLAggregateExpr(funcName());
    aggregate.addArgument(arg0.toExpression());
    if (hasWithDistinct()) {
        aggregate.setOption(SQLAggregateOption.DISTINCT);
    }
    return aggregate;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
public void setExpr(SQLExpr expr) {
    if (expr != null) {
        expr.setParent(this);
    }
    
    this.expr = expr;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
private static boolean isLogicalExpression(SQLExpr expr) { //XOR?
    if (!(expr instanceof SQLBinaryOpExpr)) {
        return false;
    }
    SQLBinaryOpExpr binOpExpr = (SQLBinaryOpExpr) expr;
    return binOpExpr.getOperator() == SQLBinaryOperator.BooleanAnd || binOpExpr.getOperator() == SQLBinaryOperator.BooleanOr;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
public static SQLExpr unwrap(SQLExpr expr) {
    if (expr == null) {
        return null;
    }

    if (expr instanceof SQLQueryExpr) {
        SQLSelect select = ((SQLQueryExpr) expr).getSubQuery();
        if (select == null) {
            return null;
        }
        if (select.getQuery() instanceof SQLSelectQueryBlock) {
            SQLSelectQueryBlock queryBlock = (SQLSelectQueryBlock) select.getQuery();
            if (queryBlock.getFrom() == null) {
                if (queryBlock.getSelectList().size() == 1) {
                    return queryBlock.getSelectList().get(0).getExpr();
                }
            }
        }
    }

    return expr;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
@Override
public SQLSelectBuilderImpl having(String expr) {
    SQLSelectQueryBlock queryBlock = getQueryBlock();

    SQLSelectGroupByClause groupBy = queryBlock.getGroupBy();
    if (groupBy == null) {
        groupBy = createGroupBy();
        queryBlock.setGroupBy(groupBy);
    }

    SQLExpr exprObj = SQLUtils.toSQLExpr(expr, dbType);
    groupBy.setHaving(exprObj);

    return this;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
protected SQLAlterTableAlterColumn parseAlterColumn() {
    if (lexer.token() == Token.COLUMN) {
        lexer.nextToken();
    }

    SQLColumnDefinition column = this.exprParser.parseColumn();

    SQLAlterTableAlterColumn alterColumn = new SQLAlterTableAlterColumn();
    alterColumn.setColumn(column);

    if (column.getDataType() == null && column.getConstraints().size() == 0) {
        if (lexer.token() == Token.SET) {
            lexer.nextToken();
            if (lexer.token() == Token.NOT) {
                lexer.nextToken();
                accept(Token.NULL);
                alterColumn.setSetNotNull(true);
            } else {
                accept(Token.DEFAULT);
                SQLExpr defaultValue = this.exprParser.expr();
                alterColumn.setSetDefault(defaultValue);
            }
        } else if (lexer.token() == Token.DROP) {
            lexer.nextToken();
            if (lexer.token() == Token.NOT) {
                lexer.nextToken();
                accept(Token.NULL);
                alterColumn.setDropNotNull(true);
            } else {
                accept(Token.DEFAULT);
                alterColumn.setDropDefault(true);
            }
        }
    }
    return alterColumn;
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
/**
 * 循环寻找子WhereUnit（实际是嵌套的or）
 * @param whereUnitList
 */
private void loopFindSubWhereUnit(List<WhereUnit> whereUnitList) {
	List<WhereUnit> subWhereUnits = new ArrayList<WhereUnit>();
	for(WhereUnit whereUnit : whereUnitList) {
		if(whereUnit.getSplitedExprList().size() > 0) {
			List<SQLExpr> removeSplitedList = new ArrayList<SQLExpr>();
			for(SQLExpr sqlExpr : whereUnit.getSplitedExprList()) {
				reset();
				if(isExprHasOr(sqlExpr)) {
					removeSplitedList.add(sqlExpr);
					WhereUnit subWhereUnit = this.whereUnits.get(0);
					splitUntilNoOr(subWhereUnit);
					whereUnit.addSubWhereUnit(subWhereUnit);
					subWhereUnits.add(subWhereUnit);
				} else {
					this.conditions.clear();
				}
			}
			if(removeSplitedList.size() > 0) {
				whereUnit.getSplitedExprList().removeAll(removeSplitedList);
			}
		}
		subWhereUnits.addAll(whereUnit.getSubWhereUnit());
	}
	if(subWhereUnits.size() > 0) {
		loopFindSubWhereUnit(subWhereUnits);
	}
}
 

import com.alibaba.druid.sql.ast.SQLExpr; //导入依赖的package包/类
@Override
public SQLExpr toExpression() {
    SQLMethodInvokeExpr method = new SQLMethodInvokeExpr(funcName());
    for (Item arg : args) {
        method.addParameter(arg.toExpression());
    }
    return method;
}