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; } }
public Object visit(PropertyIsBetween filter, Object arg1) { Expression expression = filter.getExpression(); Expression lower = filter.getLowerBoundary(); Expression upper = filter.getUpperBoundary(); List expressions = (List) expression.accept(this, null); List lowerExpressions = (List) lower.accept(this, null); List upperExpressions = (List) upper.accept(this, null); final int combinedSize = expressions.size() * lowerExpressions.size() * upperExpressions.size(); List combinedFilters = new ArrayList(combinedSize); for (Iterator lowers = lowerExpressions.iterator(); lowers.hasNext(); ) { Expression floor = (Expression) lowers.next(); for (Iterator exprs = expressions.iterator(); exprs.hasNext(); ) { Expression prop = (Expression) exprs.next(); for (Iterator uppers = upperExpressions.iterator(); uppers.hasNext(); ) { Expression roof = (Expression) uppers.next(); Filter newFilter = ff.between(prop, floor, roof, filter.getMatchAction()); combinedFilters.add(newFilter); } } } Filter unrolled = combineOred(combinedFilters); return unrolled; }
public static Object buildBetween(PropertyIsBetween filter, Object extraData) { LOGGER.finer("exporting PropertyIsBetween"); ExpressionVisitor exprVisitor = new ExpressionToText(); StringBuilder output = asStringBuilder(extraData); PropertyName propertyName = (PropertyName) filter.getExpression(); propertyName.accept(exprVisitor, output); output.append(" BETWEEN "); filter.getLowerBoundary().accept(exprVisitor, output); output.append(" AND "); filter.getUpperBoundary().accept(exprVisitor, output); return output; }
public void visitArrayBetween(PropertyIsBetween filter, Class context, Object extraData) { Expression expr = filter.getExpression(); Expression lowerbounds = filter.getLowerBoundary(); Expression upperbounds = filter.getUpperBoundary();
/** * 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 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 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; }
/** * 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 = (Expression) filter.getExpression(); Expression lowerbounds = (Expression) filter.getLowerBoundary(); Expression upperbounds = (Expression) filter.getUpperBoundary(); Class context; AttributeDescriptor attType = (AttributeDescriptor) expr.evaluate(featureType); if (attType != null) { context = attType.getType().getBinding(); } else { // assume it's a string? context = String.class; } try { expr.accept(this, extraData); out.write(" BETWEEN "); lowerbounds.accept(this, context); out.write(" AND "); upperbounds.accept(this, context); } catch (java.io.IOException ioe) { throw new RuntimeException(IO_ERROR, ioe); } return extraData; }
@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()); }
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; }
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; }
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; } }
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); }
public Object visit(PropertyIsBetween filter, Object extraData) { Expression expr = visit(filter.getExpression(), extraData); Expression lower = visit(filter.getLowerBoundary(), extraData); Expression upper = visit(filter.getUpperBoundary(), extraData); return getFactory(extraData).between(expr, lower, upper, filter.getMatchAction()); }
@Override public Object visit(PropertyIsBetween filter, Object extraData) { BasicDBObject output = asDBObject(extraData); String propName = convert(filter.getExpression().accept(this, null), String.class); Object lower = filter.getLowerBoundary().accept(this, getValueType(filter.getExpression())); Object upper = filter.getUpperBoundary().accept(this, getValueType(filter.getExpression())); BasicDBObject dbo = new BasicDBObject(); dbo.put("$gte", lower); dbo.put("$lte", upper); output.put(propName, dbo); return output; }
public Object visit(PropertyIsBetween filter, Object extraData) { Expression left = (Expression) filter.getLowerBoundary(); Expression mid = (Expression) filter.getExpression(); Expression right = (Expression) filter.getUpperBoundary(); String type = "PropertyIsBetween"; start(type); mid.accept(this, extraData); start("LowerBoundary"); left.accept(this, extraData); end("LowerBoundary"); start("UpperBoundary"); right.accept(this, extraData); end("UpperBoundary"); end(type); return extraData; }
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); }
/** * @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()); } }
assertEquals( "determinand_description_3_3", ((Literal) unmappedDeterm.getUpperBoundary()).getValue());
@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()); } }