/** * @see java.lang.Object#clone() */ public Object clone() { Expression expr = (Expression)expression.clone(); int whenCount = getWhenCount(); ArrayList whenCopy = new ArrayList(whenCount); ArrayList thenCopy = new ArrayList(whenCount); for(int i = 0; i < whenCount; i++) { whenCopy.add(getWhenExpression(i).clone()); thenCopy.add(getThenExpression(i).clone()); } Expression elseExpr = getElseExpression(); if (elseExpr != null) { elseExpr = (Expression)elseExpr.clone(); } CaseExpression copy = new CaseExpression(expr, whenCopy, thenCopy); copy.setType(getType()); copy.setElseExpression(elseExpr); return copy; }
public void visit(CaseExpression obj) { obj.setExpression(replaceExpression(obj.getExpression())); final int whenCount = obj.getWhenCount(); ArrayList whens = new ArrayList(whenCount); ArrayList thens = new ArrayList(whenCount); for (int i = 0; i < whenCount; i++) { whens.add(replaceExpression(obj.getWhenExpression(i))); thens.add(replaceExpression(obj.getThenExpression(i))); } obj.setWhen(whens, thens); if (obj.getElseExpression() != null) { obj.setElseExpression(replaceExpression(obj.getElseExpression())); } }
private Expression rewriteCaseExpression(CaseExpression expr) throws TeiidComponentException, TeiidProcessingException{ List<CompareCriteria> whens = new ArrayList<CompareCriteria>(expr.getWhenCount()); for (Expression expression: (List<Expression>)expr.getWhen()) { whens.add(new CompareCriteria((Expression)expr.getExpression().clone(), CompareCriteria.EQ, expression)); } SearchedCaseExpression sce = new SearchedCaseExpression(whens, expr.getThen()); sce.setElseExpression(expr.getElseExpression()); sce.setType(expr.getType()); return rewriteCaseExpression(sce); }
private Object evaluate(CaseExpression expr, List<?> tuple) throws ExpressionEvaluationException, BlockedException, TeiidComponentException { Object exprVal = internalEvaluate(expr.getExpression(), tuple); for (int i = 0; i < expr.getWhenCount(); i++) { if (EquivalenceUtil.areEqual(exprVal, internalEvaluate(expr.getWhenExpression(i), tuple))) { return internalEvaluate(expr.getThenExpression(i), tuple); } } if (expr.getElseExpression() != null) { return internalEvaluate(expr.getElseExpression(), tuple); } return null; }
public static CaseExpression example(int whens) { ElementSymbol x = new ElementSymbol("x"); //$NON-NLS-1$ CaseExpression caseExpr = new CaseExpression(x, getWhenExpressions(whens), getThenExpressions(whens)); caseExpr.setElseExpression(new Constant(new Integer(9999))); return caseExpr; }
caseExpr.setWhen(null, null); fail("Setting WHEN and THEN to null should have failed."); //$NON-NLS-1$ } catch (IllegalArgumentException e) { caseExpr.setWhen(getWhenExpressions(2), null); fail("Setting THEN to null should have failed."); //$NON-NLS-1$ } catch (IllegalArgumentException e) { caseExpr.setWhen(null, getThenExpressions(2)); fail("Setting WHEN to null should have failed."); //$NON-NLS-1$ } catch (IllegalArgumentException e) { caseExpr.setWhen(getWhenExpressions(0), getThenExpressions(0)); fail("Setting WHEN and THEN to empty lists should have failed."); //$NON-NLS-1$ } catch (IllegalArgumentException e) { caseExpr.setWhen(TestSearchedCaseExpression.getWhenCriteria(3), getThenExpressions(3)); caseExpr.setWhen(getWhenExpressions(3), TestSearchedCaseExpression.getWhenCriteria(3)); ArrayList whens = new ArrayList(); whens.add(new Constant("abc")); //$NON-NLS-1$ thens.add(new Constant(new Integer(20000))); thens.add(new Constant(new Integer(30000))); caseExpr.setWhen(whens, thens); assertEquals(2, caseExpr.getWhenCount()); assertEquals(new Constant("abc"), caseExpr.getWhenExpression(0)); //$NON-NLS-1$ assertEquals(new Constant("xyz"), caseExpr.getWhenExpression(1)); //$NON-NLS-1$ assertEquals(new Constant(new Integer(20000)), caseExpr.getThenExpression(0)); assertEquals(new Constant(new Integer(30000)), caseExpr.getThenExpression(1));
public void testEquals() { CaseExpression sc1 = example(3); assertTrue(sc1.equals(sc1)); assertTrue(sc1.equals(sc1.clone())); assertTrue(sc1.clone().equals(sc1)); assertTrue(sc1.equals(example(3))); CaseExpression sc2 = example(4); assertFalse(sc1.equals(sc2)); assertFalse(sc2.equals(sc1)); CaseExpression sc3 = example(3); sc3.setElseExpression(new ElementSymbol("y")); //$NON-NLS-1$ assertFalse(sc1.equals(sc3)); assertFalse(sc3.equals(sc1)); CaseExpression sc4 = example(3); sc4.setExpression(new ElementSymbol("y")); //$NON-NLS-1$ assertFalse(sc1.equals(sc4)); assertFalse(sc4.equals(sc1)); } }
public void testSetElseExpression() { CaseExpression expr = example(3); expr.setElseExpression(new Constant(new Integer(1000))); assertEquals(new Constant(new Integer(1000)), expr.getElseExpression()); expr.setElseExpression(null); assertNull(expr.getElseExpression()); }
public void testSetExpression() { CaseExpression caseExpr = example(1); ElementSymbol y = new ElementSymbol("y"); //$NON-NLS-1$ caseExpr.setExpression(y); assertEquals(y, caseExpr.getExpression()); try { caseExpr.setExpression(null); fail("Setting the expression to null should fail."); //$NON-NLS-1$ } catch (IllegalArgumentException e) { // There should be no side-effects of an illegal argument assertEquals(y, caseExpr.getExpression()); } }
public static void helpTestWhenExpressions(CaseExpression caseExpr, int expectedWhens) { assertEquals(expectedWhens, caseExpr.getWhenCount()); for (int i = 0; i < expectedWhens; i++) { assertEquals(new Constant(String.valueOf((char)('a' + i))), caseExpr.getWhenExpression(i)); } }
public boolean equals(Object obj) { if (!super.equals(obj)) return false; if (!(obj instanceof CaseExpression)) return false; CaseExpression other = (CaseExpression)obj; return getExpression().equals(other.getExpression()) && when.equals(other.when); } }
@Test public void testCaseExpression4() { CaseExpression example = TestCaseExpression.example(3, 2, true); example.setElseExpression(null); helpTest(example, "CASE x WHEN 'a' THEN 0 WHEN 'b' THEN 1 WHEN null THEN 2 END"); //$NON-NLS-1$ }
public void visit(CaseExpression obj) { if (obj.getType() == null){ this.unresolvedSymbols.add(obj); } }
public void testGetWhenCount() { assertEquals(1, example(1).getWhenCount()); assertEquals(2, example(2).getWhenCount()); assertEquals(3, example(3).getWhenCount()); assertEquals(4, example(4).getWhenCount()); }
public void testGetElseExpression() { CaseExpression expr = example(3); assertEquals(new Constant(new Integer(9999)), expr.getElseExpression()); }
private Object evaluate(CaseExpression expr, List<?> tuple) throws ExpressionEvaluationException, BlockedException, TeiidComponentException { Object exprVal = internalEvaluate(expr.getExpression(), tuple); for (int i = 0; i < expr.getWhenCount(); i++) { if (EquivalenceUtil.areEqual(exprVal, internalEvaluate(expr.getWhenExpression(i), tuple))) { return internalEvaluate(expr.getThenExpression(i), tuple); } } if (expr.getElseExpression() != null) { return internalEvaluate(expr.getElseExpression(), tuple); } return null; }
public static CaseExpression example(int whens, int nullIndex, boolean includeNull) { ArgCheck.isTrue(nullIndex < whens, "Null Index must be less than the number of When expressions"); //$NON-NLS-1$ ElementSymbol x = new ElementSymbol("x"); //$NON-NLS-1$ CaseExpression caseExpr = new CaseExpression(x, getWhenExpressions(whens, nullIndex, includeNull), getThenExpressions(whens)); caseExpr.setElseExpression(new Constant(new Integer(9999))); return caseExpr; }