Refine search
public Object visit(PropertyIsBetween filter, Object data) { filter.getLowerBoundary().accept(this, data); if (found) return found; filter.getExpression().accept(this, data); if (found) return found; filter.getUpperBoundary().accept(this, data); return found; }
public Object getProperty(Object object, QName name) throws Exception { PropertyIsBetween between = (PropertyIsBetween) object; // <xsd:element ref="ogc:expression"/> if (OGC.expression.equals(name)) { return between.getExpression(); } // <xsd:element name="LowerBoundary" type="ogc:LowerBoundaryType"/> if ("LowerBoundary".equals(name.getLocalPart())) { return between.getLowerBoundary(); } // <xsd:element name="UpperBoundary" type="ogc:UpperBoundaryType"/> if ("UpperBoundary".equals(name.getLocalPart())) { return between.getUpperBoundary(); } return null; } }
@Test public void between() { // among two literals PropertyIsBetween source = ff.between(ff.property("i"), ff.literal("10"), ff.literal("20")); PropertyIsBetween bound = (PropertyIsBetween) source.accept(visitor, null); assertEquals(Integer.valueOf(10), ((Literal) bound.getLowerBoundary()).getValue()); assertEquals(Integer.valueOf(20), ((Literal) bound.getUpperBoundary()).getValue()); // among two expression source = ff.between(ff.literal("10"), ff.property("i"), ff.property("i")); bound = (PropertyIsBetween) source.accept(visitor, null); assertEquals(Integer.valueOf(10), ((Literal) bound.getExpression()).getValue()); // among two inconsistent expressions, cannot optimize source = ff.between(ff.literal("10"), ff.property("i"), ff.property("d")); bound = (PropertyIsBetween) source.accept(visitor, null); assertEquals("10", ((Literal) bound.getExpression()).getValue()); } }
public Object visit(PropertyIsBetween filter, Object extraData) { return handle( filter, extraData, filter.getLowerBoundary(), filter.getUpperBoundary(), filter.getUpperBoundary()); }
@Test public void testBetweenFilter() throws Exception { PropertyIsBetween bf = ff.between( ff.property("measurement/result"), ff.literal(1), ff.literal(2), MatchAction.ALL); PropertyIsBetween unrolled = (PropertyIsBetween) bf.accept(visitor, null); assertEquals(MatchAction.ALL, ((PropertyIsBetween) unrolled).getMatchAction()); Expression att = unrolled.getExpression(); assertTrue(att instanceof PropertyName); String propertyName = ((PropertyName) att).getPropertyName(); assertEquals("results_value", propertyName); }
/** * Writes the SQL for the PropertyIsBetween Filter. * * @param filter the Filter to be visited. * @throws RuntimeException for io exception with writer */ public Object visit(PropertyIsBetween filter, Object extraData) throws RuntimeException { LOGGER.finer("exporting PropertyIsBetween"); Expression expr = filter.getExpression(); Class context = super.getExpressionType(expr); if (helper.isArray(context)) { helper.out = out; helper.visitArrayBetween(filter, context.getComponentType(), extraData); return extraData; } else { return super.visit(filter, extraData); } }
@Test public void testBetween() { PropertyIsBetween between = ff.between(ff.property("a"), ff.property("b"), ff.property("c")); NullHandlingVisitor visitor = new NullHandlingVisitor(); Filter result = (Filter) between.accept(visitor, null); assertTrue(result instanceof And); Filter expected = ff.and( Arrays.asList( between, propertyNotNull("a"), propertyNotNull("b"), propertyNotNull("c"))); assertEquals(expected, result); between = ff.between(ff.property("a"), ff.property("b"), ff.literal(10)); result = (Filter) between.accept(visitor, null); assertTrue(result instanceof And); expected = ff.and(Arrays.asList(between, propertyNotNull("a"), propertyNotNull("b"))); assertEquals(expected, result); between = ff.between(ff.property("a"), ff.literal(5), ff.literal(10)); result = (Filter) between.accept(visitor, null); assertTrue(result instanceof And); expected = ff.and(Arrays.asList(between, propertyNotNull("a"))); assertEquals(expected, result); between = ff.between(ff.literal(7), ff.literal(5), ff.literal(10)); result = (Filter) between.accept(visitor, null); assertEquals(between, result); }
public Object visit(PropertyIsBetween filter, Object extraData) { PropertyIsBetween clone = (PropertyIsBetween) super.visit(filter, extraData); Filter f = guardAgainstNulls(clone, clone.getExpression()); f = guardAgainstNulls(f, clone.getLowerBoundary()); f = guardAgainstNulls(f, clone.getUpperBoundary()); return f; }
@Test public void testBetweenFilter() throws Exception { PropertyIsBetween bf = ff.between(ff.property("measurement/result"), ff.literal(1), ff .literal(2), MatchAction.ALL); PropertyIsBetween unrolled = (PropertyIsBetween) bf.accept(visitor, null); assertEquals(MatchAction.ALL, ((PropertyIsBetween) unrolled).getMatchAction()); Expression att = unrolled.getExpression(); assertTrue(att instanceof PropertyName); String propertyName = ((PropertyName) att).getPropertyName(); assertEquals("results_value", propertyName); }
/** * Writes the SQL for the PropertyIsBetween Filter. * * @param filter the Filter to be visited. * @throws RuntimeException for io exception with writer */ public Object visit(PropertyIsBetween filter, Object extraData) throws RuntimeException { LOGGER.finer("exporting PropertyIsBetween"); Expression expr = filter.getExpression(); Class context = super.getExpressionType(expr); if (helper.isArray(context)) { helper.out = out; helper.visitArrayBetween(filter, context.getComponentType(), extraData); return extraData; } else { return super.visit(filter, extraData); } }
@Test public void testNullableAttributes() { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.nillable(true); tb.add("a", String.class); tb.nillable(false); tb.add("b", String.class); tb.nillable(true); tb.add("c", String.class); tb.setName("test"); SimpleFeatureType schema = tb.buildFeatureType(); PropertyIsBetween between = ff.between(ff.property("a"), ff.property("b"), ff.property("c")); NullHandlingVisitor visitor = new NullHandlingVisitor(schema); Filter result = (Filter) between.accept(visitor, null); assertTrue(result instanceof And); Filter expected = ff.and(Arrays.asList(between, propertyNotNull("a"), propertyNotNull("c"))); assertEquals(expected, result); }
public Object visit(PropertyIsBetween filter, Object data) { data = filter.getLowerBoundary().accept(this, data); data = filter.getExpression().accept(this, data); data = filter.getUpperBoundary().accept(this, data); return data; }
public Object visit(PropertyIsBetween filter, Object extraData) { PropertyIsBetween clone = (PropertyIsBetween) super.visit(filter, extraData); if (isConstant(clone.getExpression()) && isConstant(clone.getLowerBoundary()) && isConstant(clone.getUpperBoundary())) { return staticFilterEvaluate(clone); } else { return clone; } }
/** * Visits filter.getLowerBoundary(),filter.getExpression(),filter.getUpperBoundary() if an * expression visitor was set. */ public Object visit(PropertyIsBetween filter, Object data) { if (filter.getLowerBoundary() != null) { filter.getLowerBoundary().accept(expressionVisitor, data); } if (filter.getExpression() != null) { filter.getExpression().accept(expressionVisitor, data); } if (filter.getUpperBoundary() != null) { filter.getUpperBoundary().accept(expressionVisitor, data); } return filter; }
public void testParse() throws Exception { FilterMockData.propertyIsBetween(document, document); PropertyIsBetween between = (PropertyIsBetween) parse(); assertTrue(between.getExpression() instanceof PropertyName); assertTrue(between.getLowerBoundary() instanceof Literal); assertTrue(between.getUpperBoundary() instanceof Literal); }
public Object visit(PropertyIsBetween filter, Object data) { data = filter.getLowerBoundary().accept(this, data); if (found(data)) return data; data = filter.getExpression().accept(this, data); if (found(data)) return data; data = filter.getUpperBoundary().accept(this, data); return data; }
/** * @see org.geotools.xml.schema.Type#encode(org.geotools.xml.schema.Element, * java.lang.Object, org.geotools.xml.PrintHandler, java.util.Map) */ public void encode(Element element, Object value, PrintHandler output, Map hints) throws IOException, OperationNotSupportedException { if (!canEncode(element, value, hints)) { return; } PropertyIsBetween lf = (PropertyIsBetween) value; output.startElement(element.getNamespace(), element.getName(), null); encodeExpr(lf.getExpression(), output, hints); elems[1].getType() .encode(elems[1], lf.getLowerBoundary(), output, hints); // LowerBoundary elems[2].getType() .encode(elems[2], lf.getUpperBoundary(), output, hints); // UpperBoundary output.endElement(element.getNamespace(), element.getName()); } }
@Override public Object visit(PropertyIsBetween filter, Object extraData) { Class targetType = getTargetType( filter.getLowerBoundary(), filter.getExpression(), filter.getUpperBoundary()); Expression lb = optimize(filter.getLowerBoundary(), extraData, targetType); Expression ex = optimize(filter.getExpression(), extraData, targetType); Expression ub = optimize(filter.getUpperBoundary(), extraData, targetType); return getFactory(extraData).between(ex, lb, ub, filter.getMatchAction()); }
if (f instanceof PropertyIsBetween) { PropertyIsBetween pb = (PropertyIsBetween) f; Class binding = getTypeIfComparable(pb.getExpression()); if (binding == null) { otherFilters.add(pb); } else { Object min = evaluate(pb.getLowerBoundary(), binding); Object max = evaluate(pb.getUpperBoundary(), binding); if (min == null || max == null) { otherFilters.add(f); } else { Expression expression = pb.getExpression(); Range<?> range = new Range(binding, (Comparable) min, (Comparable) max); addRange(rangeMap, expression, new MultiRange(range));
public Object visit(PropertyIsBetween filter, Object extraData) { ScalarCapabilities scalar = capabilities.getScalarCapabilities(); if (scalar == null) return false; ComparisonOperators operators = scalar.getComparisonOperators(); if (operators == null) return false; if (operators.getOperator(PropertyIsBetween.NAME) == null) return false; return (Boolean) filter.getLowerBoundary().accept(this, null) && (Boolean) filter.getExpression().accept(this, null) && (Boolean) filter.getUpperBoundary().accept(this, null); }