public Object visit(PropertyIsEqualTo filter, Object data) { filter.getExpression1().accept(this, data); if (found) return found; filter.getExpression2().accept(this, data); return found; }
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 void testResolvePropertyName() { PropertyIsEqualTo f = factory.equal(factory.property("gml:name"), factory.literal("foo"), true); assertEquals("gml:name", f.getExpression1().toString()); f = (PropertyIsEqualTo) f.accept(new PropertyNameResolvingVisitor(featureType), null); assertEquals("name", f.getExpression1().toString()); }
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 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; } }
@Test public void equalsTest() { // forward PropertyIsEqualTo source = ff.equal(ff.property("i"), ff.literal("10"), true); PropertyIsEqualTo bound = (PropertyIsEqualTo) source.accept(visitor, null); assertEquals(Integer.valueOf(10), ((Literal) bound.getExpression2()).getValue()); // flip it source = ff.equal(ff.literal("10"), ff.property("i"), true); bound = (PropertyIsEqualTo) source.accept(visitor, null); assertEquals(Integer.valueOf(10), ((Literal) bound.getExpression1()).getValue()); }
private Object buildExists(PropertyIsEqualTo filter, StringBuilder output) { Function function = (Function) filter.getExpression1(); List<Expression> parameters = function.getParameters(); Literal arg = (Literal) parameters.get(0); output.append(arg.getValue()); output.append(" EXISTS"); return output; }
public void testCompareFunctionNull() { Function f = ff.function("env", ff.literal("var")); PropertyIsEqualTo filter = ff.equal(f, ff.literal("test"), false); Filter simplified = (Filter) filter.accept(simpleVisitor, null); assertEquals(Filter.EXCLUDE, simplified); }
} 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;
public void testPropertyEqualWithFunction() throws Exception { Function function = new GeometryFunction(); // see if coordinates gets flipped, urn forces lat/lon interpretation PropertyIsEqualTo original = ff.equals(ff.property("geom"), function); PropertyIsEqualTo clone = (PropertyIsEqualTo) original.accept(reprojector, null); assertNotSame(original, clone); assertEquals(clone.getExpression1(), original.getExpression1()); LineString clonedLs = (LineString) clone.getExpression2().evaluate(null); assertTrue(15 == clonedLs.getCoordinateN(0).x); assertTrue(10 == clonedLs.getCoordinateN(0).y); assertTrue(25 == clonedLs.getCoordinateN(1).x); assertTrue(20 == clonedLs.getCoordinateN(1).y); assertEquals(CRS.decode("EPSG:4326"), clonedLs.getUserData()); }
/** Check if this is an encoding of ECQL IN */ private boolean isInFilter(Or filter) { if (filter.getChildren() == null) { return false; } Expression left = null; for (Filter child : filter.getChildren()) { if (child instanceof PropertyIsEqualTo) { PropertyIsEqualTo equal = (PropertyIsEqualTo) child; if (left == null) { left = equal.getExpression1(); } else if (!left.equals(equal.getExpression1())) { return false; // not IN } } else { return false; // not IN } } return true; }
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 void testCompareConstantFunction() { EnvFunction.setLocalValue("var", "test"); Function f = ff.function("env", ff.literal("var")); PropertyIsEqualTo filter = ff.equal(f, ff.literal("test"), false); Filter simplified = (Filter) filter.accept(simpleVisitor, null); assertEquals(Filter.INCLUDE, simplified); }
public Object visit(PropertyIsEqualTo filter, Object data) { data = filter.getExpression1().accept(this, data); data = filter.getExpression2().accept(this, data); return data; }
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) { Expression expr1= visit(filter.getExpression1(), extraData); Expression expr2= visit(filter.getExpression2(), extraData); boolean matchCase=filter.isMatchingCase(); return getFactory(extraData).equal(expr1, expr2, matchCase); }
Filter unrolled = (Filter) complexFilter.accept(visitor, null); assertNotNull(unrolled); assertNotSame(complexFilter, unrolled); PropertyIsEqualTo filter4 = (PropertyIsEqualTo) children.get(3); assertTrue(filter1.getExpression1() instanceof Function); assertTrue(filter2.getExpression1() instanceof PropertyName); assertTrue(filter3.getExpression1() instanceof PropertyName); assertTrue(filter4.getExpression1() instanceof PropertyName); assertTrue(filter1.getExpression2() instanceof Literal); assertTrue(filter2.getExpression2() instanceof Literal); assertTrue(filter3.getExpression2() instanceof Literal); assertTrue(filter4.getExpression2() instanceof Literal); assertEquals("BGS_ID", ((PropertyName) filter2.getExpression1()).getPropertyName()); assertEquals("NAME", ((PropertyName) filter3.getExpression1()).getPropertyName()); assertEquals("ORIGINAL_N", ((PropertyName) filter4.getExpression1()).getPropertyName());
private Object buildRelate(PropertyIsEqualTo filter, StringBuilder output) { Function operation = (Function) filter.getExpression1(); output.append("RELATE("); List<Expression> parameters = operation.getParameters(); Expression arg1 = parameters.get(0); Expression arg2 = parameters.get(1); Literal arg3 = (Literal) parameters.get(2); arg1.accept(expressionVisitor, output); output.append(","); arg2.accept(expressionVisitor, output); output.append(","); output.append(arg3.getValue()); output.append(")"); return output; }
@Test public void testBinaryComparison() { PropertyIsEqualTo equal = ff.equal(ff.property("a"), ff.property("b"), false); NullHandlingVisitor visitor = new NullHandlingVisitor(); Filter result = (Filter) equal.accept(visitor, null); assertTrue(result instanceof And); Filter expected = ff.and(Arrays.asList(equal, propertyNotNull("a"), propertyNotNull("b"))); assertEquals(expected, result); equal = ff.equal(ff.property("a"), ff.literal(10), false); result = (Filter) equal.accept(visitor, null); assertTrue(result instanceof And); expected = ff.and(Arrays.asList(equal, propertyNotNull("a"))); assertEquals(expected, result); equal = ff.equal(ff.literal(10), ff.property("b"), false); result = (Filter) equal.accept(visitor, null); assertTrue(result instanceof And); expected = ff.and(Arrays.asList(equal, propertyNotNull("b"))); assertEquals(expected, result); equal = ff.equal(ff.literal(10), ff.literal(20), false); result = (Filter) equal.accept(visitor, null); assertEquals(equal, result); }
private FilterFunction_sdonn getSDO_NN_Query(PropertyIsEqualTo filter) { Expression expr1 = filter.getExpression1(); Expression expr2 = filter.getExpression2(); if (expr2 instanceof FilterFunction_sdonn) { // switch position Expression tmp = expr1; expr1 = expr2; expr2 = tmp; } if (expr1 instanceof FilterFunction_sdonn) { if (!(expr2 instanceof Literal)) { throw new UnsupportedOperationException( "Unsupported usage of SDO_NN Oracle function: it can be compared only to a Boolean \"true\" value"); } Boolean nearest = (Boolean) evaluateLiteral((Literal) expr2, Boolean.class); if (nearest == null || !nearest.booleanValue()) { throw new UnsupportedOperationException( "Unsupported usage of SDO_NN Oracle function: it can be compared only to a Boolean \"true\" value"); } return (FilterFunction_sdonn) expr1; } else { return null; } }