public Object visit(PropertyIsEqualTo filter, Object arg1) { Expression[][] expressions = visitBinaryComparisonOperator(filter); List combinedFilters = new ArrayList(expressions.length); for (int i = 0; i < expressions.length; i++) { Expression left = expressions[i][0]; Expression right = expressions[i][1]; Filter unrolled = ff.equal(left, right, filter.isMatchingCase(), filter.getMatchAction()); combinedFilters.add(unrolled); } Filter unrolled = combineOred(combinedFilters); return unrolled; }
public Object visit(PropertyIsEqualTo filter, Object extraData) { Expression expr1 = visit(filter.getExpression1(), extraData); Expression expr2 = visit(filter.getExpression2(), extraData); boolean matchCase = filter.isMatchingCase(); return getFactory(extraData).equal(expr1, expr2, matchCase, filter.getMatchAction()); }
public Object visit(PropertyIsEqualTo filter, Object extraData) { Class targetType = getTargetType(filter.getExpression1(), filter.getExpression2()); Expression expr1 = optimize(filter.getExpression1(), extraData, targetType); Expression expr2 = optimize(filter.getExpression2(), extraData, targetType); boolean matchCase = filter.isMatchingCase(); return getFactory(extraData).equal(expr1, expr2, matchCase, filter.getMatchAction()); }
public boolean isSimpleEquals(Filter expression) { if (expression instanceof PropertyIsEqualTo) { PropertyIsEqualTo equals = (PropertyIsEqualTo) expression; if ((equals.getExpression1() instanceof PropertyName) && (equals .getExpression2() instanceof Literal) && (equals.isMatchingCase())) return true; } return false; } }
} else if (simplified instanceof PropertyIsEqualTo) { PropertyIsEqualTo pe = (PropertyIsEqualTo) simplified; return ff.notEqual(pe.getExpression1(), pe.getExpression2(), pe.isMatchingCase()); } else if (simplified instanceof PropertyIsNotEqualTo) { PropertyIsNotEqualTo pe = (PropertyIsNotEqualTo) simplified;
@Test public void testCompareFilter() throws Exception { PropertyIsEqualTo complexFilter = ff.equal(ff.property("measurement/result"), ff.literal(1.1), true, MatchAction.ALL); Filter unrolled = (Filter) complexFilter.accept(visitor, null); assertNotNull(unrolled); assertTrue(unrolled instanceof PropertyIsEqualTo); assertNotSame(complexFilter, unrolled); assertTrue(((PropertyIsEqualTo) unrolled).isMatchingCase()); assertEquals(MatchAction.ALL, ((PropertyIsEqualTo) unrolled).getMatchAction()); Expression left = ((PropertyIsEqualTo) unrolled).getExpression1(); Expression right = ((PropertyIsEqualTo) unrolled).getExpression2(); assertTrue(left instanceof PropertyName); assertTrue(right instanceof Literal); PropertyName attExp = (PropertyName) left; String expectedAtt = "results_value"; assertEquals(expectedAtt, attExp.getPropertyName()); assertEquals(new Double(1.1), ((Literal) right).getValue()); }
public Object visit(PropertyIsEqualTo filter, Object arg1) { Expression[][] expressions = visitBinaryComparisonOperator(filter); List combinedFilters = new ArrayList(expressions.length); for (int i = 0; i < expressions.length; i++) { Expression left = expressions[i][0]; Expression right = expressions[i][1]; Filter unrolled = ff.equal(left, right, filter.isMatchingCase(), filter.getMatchAction()); combinedFilters.add(unrolled); } Filter unrolled = combineOred(combinedFilters); return unrolled; }
public Object visit(PropertyIsEqualTo filter, Object extraData) { Expression expr1= visit(filter.getExpression1(), extraData); Expression expr2= visit(filter.getExpression2(), extraData); boolean matchCase=filter.isMatchingCase(); return getFactory(extraData).equal(expr1, expr2, matchCase); }
public Object visit(PropertyIsEqualTo filter, Object extraData) { Expression expr1=(Expression) filter.getExpression1().accept(this, extraData); Expression expr2=(Expression) filter.getExpression2().accept(this, extraData); boolean matchCase=filter.isMatchingCase(); return getFactory(extraData).equal(expr1, expr2, matchCase); }
public Object visit(PropertyIsEqualTo filter, Object extraData) { Expression expr1 = visitBinaryChild(filter.getExpression1(), extraData, 0); Expression expr2 = visitBinaryChild(filter.getExpression2(), extraData, 1); boolean matchCase = filter.isMatchingCase(); return getFactory(extraData).equal(expr1, expr2, matchCase, filter.getMatchAction()); }
@Test public void testCompareFilter() throws Exception { PropertyIsEqualTo complexFilter = ff.equal(ff.property("measurement/result"), ff .literal(1.1), true, MatchAction.ALL); Filter unrolled = (Filter) complexFilter.accept(visitor, null); assertNotNull(unrolled); assertTrue(unrolled instanceof PropertyIsEqualTo); assertNotSame(complexFilter, unrolled); assertTrue(((PropertyIsEqualTo) unrolled).isMatchingCase()); assertEquals(MatchAction.ALL, ((PropertyIsEqualTo) unrolled).getMatchAction()); Expression left = ((PropertyIsEqualTo) unrolled).getExpression1(); Expression right = ((PropertyIsEqualTo) unrolled).getExpression2(); assertTrue(left instanceof PropertyName); assertTrue(right instanceof Literal); PropertyName attExp = (PropertyName) left; String expectedAtt = "results_value"; assertEquals(expectedAtt, attExp.getPropertyName()); assertEquals(new Double(1.1), ((Literal) right).getValue()); }