net.sf.jsqlparser.expression.operators.conditional.OrExpression Java Examples

@Override
public String toString() {
	// jsqlparse 2.1+版本已移除not
	StringBuilder sb = new StringBuilder(/*isNot() ? "NOT " : ""*/);
	
	if(getLeftExpression() instanceof OrExpression) {
		sb.append("(").append(getLeftExpression()).append(")");
	} else {
		sb.append(getLeftExpression());
	}
	
	sb.append(" ").append(getStringExpression()).append(" ");
	
	if(getRightExpression() instanceof OrExpression) {
		sb.append("(").append(getRightExpression()).append(")");
	} else {
		sb.append(getRightExpression());
	}
	
	return sb.toString().trim().isEmpty() ? " " : "("+sb.toString()+")";
}
 

private int EvalExprType(Expression where)
{
if (where instanceof AndExpression)
    return (EXPR_AND);
else if (where instanceof OrExpression)
    return (EXPR_OR);
else if (where instanceof BinaryExpression)
    return(EXPR_BASIC);
else if (where instanceof Function)
    return(EXPR_FUNCT);
else if (where instanceof Parenthesis)
    return (EXPR_PAR);
else if (where instanceof InExpression) 
    return (EXPR_IN);
else if (where instanceof NotExpression) 
    return (EXPR_NOT);
return(-1);
}
 

@Override
public void visit(OrExpression exp) {
	//visitBinary(orExpression, true);
	clear();
	boolean prevIsTopVal = isTopLevel;
	boolean tmpLeftTableFound = false;
	boolean tmpRightTableFound = false;
	isTopLevel = false;
	exp.getLeftExpression().accept(this);
	// update tmp
	tmpLeftTableFound |= leftTableFound;
	tmpRightTableFound |= rightTableFound;
	//
	exp.getRightExpression().accept(this);
	//update tmp
	tmpLeftTableFound |= leftTableFound;
	tmpRightTableFound |= rightTableFound;
	//
	
	// update 
	leftTableFound = tmpLeftTableFound;
	rightTableFound = tmpRightTableFound;
	whereOnlyExpFound = true;
	//
	
	isTopLevel = prevIsTopVal;
	defaultTopLevelProcessing(exp);
	
	
}
 

protected void visitBinaryExpression(BinaryExpression expr) {
  	this.isBaseAliasOrValue = true;
  	expr.getLeftExpression().accept(this);
  	if(!this.isBaseAliasOrValue) {
  		expr.getRightExpression().accept(this);
}
  	else {
  		expr.getRightExpression().accept(this);
          if(this.isBaseAliasOrValue && !(expr instanceof AndExpression || expr instanceof OrExpression)) {
  			this.setOrAndExpression(outputMatch,expr);
  		}
  	}
  }
 

@Override
public void visit(OrExpression arg0) {
	Expression e = visitExpression(arg0.getLeftExpression());
	if (e != null) arg0.setLeftExpression(e);
	e = visitExpression(arg0.getRightExpression());
	if (e != null) arg0.setRightExpression(e);
}
 

private static Condition handleExpression(Condition condition, Expression expr)
        throws FrontException {
    if (expr instanceof BinaryExpression) {
        condition = getWhereClause((BinaryExpression) (expr), condition);
    }
    if (expr instanceof OrExpression) {
        throw new FrontException(PrecompiledUtils.CRUD_SQL_ERROR, "The OrExpression is not supported.");
    }
    if (expr instanceof NotExpression) {
        throw new FrontException(PrecompiledUtils.CRUD_SQL_ERROR, "The NotExpression is not supported.");
    }
    if (expr instanceof InExpression) {
        throw new FrontException(PrecompiledUtils.CRUD_SQL_ERROR, "The InExpression is not supported.");
    }
    if (expr instanceof LikeExpression) {
        throw new FrontException(PrecompiledUtils.CRUD_SQL_ERROR, "The LikeExpression is not supported.");
    }
    if (expr instanceof SubSelect) {
        throw new FrontException(PrecompiledUtils.CRUD_SQL_ERROR, "The SubSelect is not supported.");
    }
    if (expr instanceof IsNullExpression) {
        throw new FrontException(PrecompiledUtils.CRUD_SQL_ERROR, "The IsNullExpression is not supported.");
    }
    Map<String, Map<EnumOP, String>> conditions = condition.getConditions();
    Set<String> keys = conditions.keySet();
    for (String key : keys) {
        Map<EnumOP, String> value = conditions.get(key);
        EnumOP operation = value.keySet().iterator().next();
        String itemValue = value.values().iterator().next();
        String newValue = trimQuotes(itemValue);
        value.put(operation, newValue);
        conditions.put(key, value);
    }
    condition.setConditions(conditions);
    return condition;
}
 

@Override
public void visit(OrExpression arg0) {
	arg0.getLeftExpression().accept(this);
	arg0.getRightExpression().accept(this);
}
 

@Override
public void visit(OrExpression orExpression) {
    //supported construct
}
 

public void visit(OrExpression orExpression) throws Exception {
    visitBinaryExpression(orExpression);
}
 

private Conditions EvalExpr(Expression ParentExpr ) throws PDException 
{
Conditions New = new Conditions();    
int ExprType= EvalExprType(ParentExpr);
//System.out.println("ParentExpr=["+ParentExpr+"]  Type="+ExprType);    
switch (ExprType)
    {
    case EXPR_BASIC:
        ComparisonOperator CO = (ComparisonOperator) ParentExpr;
        String Left=CO.getLeftExpression().toString();
        String Comp=CO.getStringExpression();
        String Right=CO.getRightExpression().toString();
        if (isField(Left) && isField(Right))
            New.addCondition(new Condition(Left,  Right));
        else  
            {
            String FieldName;
            Object Value;
            int TypeVal;
            if (isField(Left))
                {
                FieldName=Left;
                Value=CalcVal(Right);
                TypeVal=CalcTypeVal(Right);
                }
            else
                {
                FieldName=Right;
                Value=CalcVal(Left);
                TypeVal=CalcTypeVal(Left);
                }
//            System.out.println("Value="+Value+"  class="+Value.getClass().getName());
            New.addCondition(new Condition(FieldName,  getCompConv().get(Comp), Value, TypeVal));
            }
        break;    
    case EXPR_NOT:
        Conditions Cs=EvalExpr(((NotExpression) ParentExpr).getExpression());
        Cs.setInvert(true);
        New.addCondition(Cs);
        break;
    case EXPR_AND:
        New.addCondition(EvalExpr(((AndExpression) ParentExpr).getLeftExpression() ));
        New.addCondition(EvalExpr(((AndExpression) ParentExpr).getRightExpression() ));
        break;
    case EXPR_OR:
        New.addCondition(EvalExpr(((OrExpression) ParentExpr).getLeftExpression() ));
        New.addCondition(EvalExpr(((OrExpression) ParentExpr).getRightExpression() ));
        New.setOperatorAnd(false);
        break;
    case EXPR_PAR:
        New.addCondition(EvalExpr(((Parenthesis) ParentExpr).getExpression() ));
        break;
    case EXPR_IN:
        String FieldNameIn=((InExpression)ParentExpr).getLeftExpression().toString();
        HashSet<String> ListTerms = new HashSet<String>();
        List<Expression> LT =((ExpressionList)((InExpression)ParentExpr).getLeftItemsList()).getExpressions();
        for (Iterator<Expression> iterator = LT.iterator(); iterator.hasNext();)
            {
            StringValue NextTerm = (StringValue)iterator.next();
            ListTerms.add(NextTerm.getValue());
            }
        New.addCondition(new Condition(FieldNameIn,ListTerms));
        break;
    case EXPR_FUNCT:
        String Arg=((Function)ParentExpr).getParameters().getExpressions().get(0).toString();
        switch (((Function)ParentExpr).getName())
            {
            case Condition.CONTAINS:
                New.addCondition(Condition.genContainsCond(PDDocs.getTableName(),Arg, getDrv())); 
                break;
            case Condition.INTREE:
                New.addCondition(Condition.genInTreeCond( Arg, getDrv())); 
                break;
            case Condition.INFOLDER:
                New.addCondition(Condition.genInFolder(Arg, getDrv()));
                break;
                
            }
        break;    
        
    }
return(New);
}
 

public void visit(OrExpression orExpression) {
    throw new UnsupportedOperationException("Not supported yet.");
}
 

@Override
public void visit(OrExpression orExpression) 
{
    visitBinaryExpression(orExpression);
}
 

@Override
  public void visit(OrExpression expr) {
this.haveOrExpression.setValue(true);
  }
 

private boolean isOrAndExpression(Expression expression) {
    return OrExpression.class.isInstance(expression) || AndExpression.class.isInstance(expression);
}
 

@Override
public void visit(OrExpression arg0) {
	arg0.getLeftExpression().accept(this);
	arg0.getRightExpression().accept(this);
}
 

@Override
public void visit(OrExpression arg0) {
	arg0.getLeftExpression().accept(this);
	arg0.getRightExpression().accept(this);
}
 

@Override
public void visit(OrExpression arg0) {
	arg0.getLeftExpression().accept(this);
	arg0.getRightExpression().accept(this);
}
 

@Override
public void visit(OrExpression orExpression) {
    visitBinaryExpression(orExpression);
}
 

@Override
public void visit(OrExpression arg0) {
	arg0.getLeftExpression().accept(this);
	arg0.getRightExpression().accept(this);
}
 

@Override
public void visit(OrExpression arg0) {
	arg0.getLeftExpression().accept(this);
	arg0.getRightExpression().accept(this);
}
 

public void visit(OrExpression orExpression) {
    orExpression.getLeftExpression().accept(this);
    orExpression.getRightExpression().accept(this);
}
 

@Override
public void visit(OrExpression expr) {
  invalid = true;
  super.visit(expr);
}
 

@Override
public void visit(OrExpression orExpression) {
    visitBinaryExpression(orExpression);
}