Refine search
protected Filter simplify(Filter filter) { if (Filter.INCLUDE.equals(filter) || Filter.EXCLUDE.equals(filter)) { return filter; } SimplifyingFilterVisitor simplifier = new SimplifyingFilterVisitor(); filter = (Filter) filter.accept(simplifier, null); return filter; }
private <T> void testOrOverlappingRanges(Class<T> type, T min, T max) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); // excluding extrema, not possible to turn it into a between filter Filter original = ff.or( Arrays.asList( // (Filter) ff.greater(ff.property("a"), ff.literal(min)), // ff.greater(ff.property("a"), ff.literal(max)))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(ff.greater(ff.property("a"), ff.literal(min)), simplified); }
/** * Tries to simplify the filter if it's not already a simple one. * * @param filter * @return */ public static Filter simplify(Filter filter) { return simplify(filter, null); }
/** * Tries to simplify the filter if it's not already a simple one * * @param filter * @return */ public static Filter simplify(Filter filter, FeatureType featureType) { // if already as simple as possible, or cannot be simplified anyways if (filter == Filter.INCLUDE || filter == Filter.EXCLUDE || filter == null) { return filter; } SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setFeatureType(featureType); return (Filter) filter.accept(visitor, null); }
@Override protected void setUp() throws Exception { emptyFid = ff.id(new HashSet<Identifier>()); property = ff.equal(ff.property("test"), ff.literal("oneTwoThree"), false); // visitor assuming simple features simpleVisitor = new SimplifyingFilterVisitor() { protected boolean isSimpleFeature() { return true; }; }; simpleVisitor.setRangeSimplicationEnabled(true); // one that does not know, and thus assumes complex ones complexVisitor = new SimplifyingFilterVisitor(); }
Filter[] splitFilter(Filter original) { Filter[] split = new Filter[2]; if (original != null) { // create a filter splitter PostPreProcessFilterSplittingVisitor splitter = new PostPreProcessFilterSplittingVisitor( getDataStore().getFilterCapabilities(), null, null); original.accept(splitter, null); split[0] = splitter.getFilterPre(); split[1] = splitter.getFilterPost(); } SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setFIDValidator(new PrimaryKeyFIDValidator(this)); split[0] = (Filter) split[0].accept(visitor, null); split[1] = (Filter) split[1].accept(visitor, null); return split; }
public void testRangeExpression() throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "pop:String"); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); Function func = ff.function("parseLong", ff.property("pop")); Filter f1 = ff.less(func, ff.literal(20000)); Filter f2 = ff.between(func, ff.literal(20000), ff.literal(50000)); Filter or = ff.or(f1, f2); Filter simplified = (Filter) or.accept(visitor, null); assertEquals(ff.lessOrEqual(func, ff.literal(50000)), simplified); }
private <T> void testAndTouchingRanges(Class<T> type, T value) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); Filter original = ff.and( ff.greaterOrEqual(ff.property("a"), ff.literal(value)), ff.lessOrEqual(ff.property("a"), ff.literal(value))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(ff.equal(ff.property("a"), ff.literal(value), false), simplified); }
private <T> void testAndOverlappingRangesToBetween(Class<T> type, T min, T mid, T max) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); // excluding extrema, not possible to turn it into a between filter Filter original = ff.and( Arrays.asList( // (Filter) ff.greaterOrEqual(ff.property("a"), ff.literal(min)), // ff.less(ff.property("a"), ff.literal(max)), // ff.lessOrEqual(ff.property("a"), ff.literal(mid)))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(ff.between(ff.property("a"), ff.literal(min), ff.literal(mid)), simplified); }
private <T> void testAndDisjointRanges(Class<T> type, T max, T min) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); Filter original = ff.and( ff.greater(ff.property("a"), ff.literal(max)), ff.less(ff.property("a"), ff.literal(min))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(original, simplified); visitor.setFeatureType(schema); Filter simplified2 = (Filter) original.accept(visitor, null); assertEquals(Filter.EXCLUDE, simplified2); }
private <T> void testOrTouchingRanges(Class<T> type, T value) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setRangeSimplicationEnabled(true); visitor.setFeatureType(schema); Filter original = ff.or( ff.greaterOrEqual(ff.property("a"), ff.literal(value)), ff.lessOrEqual(ff.property("a"), ff.literal(value))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(Filter.INCLUDE, simplified); }
private <T> void testOrDisjointRanges(Class<T> type, T max, T min) throws Exception { SimpleFeatureType schema = DataUtilities.createType("test", "a:" + type.getName()); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setFeatureType(schema); Filter original = ff.or( ff.greater(ff.property("a"), ff.literal(max)), ff.less(ff.property("a"), ff.literal(min))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(original, simplified); }
serverFilter = ff.and(children); SimplifyingFilterVisitor sfv = new SimplifyingFilterVisitor(); serverFilter = (Filter) serverFilter.accept(sfv, null);
public Query invertQuery( @DescribeParameter(name = "outputBBOX", description = "Georeferenced bounding box of the output") ReferencedEnvelope envelope, Query targetQuery, GridGeometry targetGridGeometry ) throws ProcessException { final BBOXRemovingFilterVisitor visitor = new BBOXRemovingFilterVisitor(); Filter filter = (Filter) targetQuery.getFilter().accept(visitor, null); final String geometryName = visitor.getGeometryPropertyName(); if (geometryName != null) { final BBOX bbox; try { if (envelope.getCoordinateReferenceSystem() != null) { envelope = envelope.transform(DefaultGeographicCRS.WGS84,false); } bbox = FILTER_FACTORY.bbox(geometryName, envelope.getMinX(), envelope.getMinY(), envelope.getMaxX(), envelope.getMaxY(), "EPSG:4326"); } catch (Exception e) { throw new ProcessException("Unable to create bbox filter for feature source", e); } filter = (Filter) FILTER_FACTORY.and(filter, bbox).accept(new SimplifyingFilterVisitor(), null); targetQuery.setFilter(filter); } final List<PropertyName> properties = new ArrayList<>(); properties.add(FILTER_FACTORY.property("_aggregation")); targetQuery.setProperties(properties); return targetQuery; }
/** * Returns a filter that includes all the visited rules * @return */ Filter getSummaryFilter() { if(filters.size() == 0) { return Filter.INCLUDE; } else if(filters.size() == 1) { return filters.get(0); } else { FilterFactory ff = CommonFactoryFinder.getFilterFactory(); Filter or = ff.or(filters); SimplifyingFilterVisitor simplifier = new SimplifyingFilterVisitor(); return (Filter) or.accept(simplifier, null); } }
Filter[] splitFilter(Filter original, FeatureSource source) { JDBCFeatureSource featureSource = null; if (source instanceof JDBCFeatureSource) { featureSource = (JDBCFeatureSource) source; } else { featureSource = ((JDBCFeatureStore) source).getFeatureSource(); } Filter[] split = new Filter[2]; if (original != null) { split = getDataStore().getSQLDialect().splitFilter(original, featureSource.getSchema()); } // handle three-valued logic differences by adding "is not null" checks in the filter, // the simplifying filter visitor will take care of them if they are redundant NullHandlingVisitor nhv = new NullHandlingVisitor(source.getSchema()); split[0] = (Filter) split[0].accept(nhv, null); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); visitor.setFIDValidator(new PrimaryKeyFIDValidator(featureSource)); visitor.setFeatureType(getSchema()); split[0] = (Filter) split[0].accept(visitor, null); split[1] = (Filter) split[1].accept(visitor, null); return split; }
public void testSimplifyNegateImpossible() throws Exception { PropertyIsEqualTo propertyIsEqualTo = ff.equal(ff.literal("a"), ff.literal("b"), true); Not negated = ff.not(propertyIsEqualTo); SimplifyingFilterVisitor visitor = new SimplifyingFilterVisitor(); SimpleFeatureType schema = DataUtilities.createType("test", "pop:String"); visitor.setFeatureType(schema); Filter simplified = (Filter) negated.accept(visitor, null); assertEquals(Filter.INCLUDE, simplified); } }
private Filter resolveNativeFilter() { Filter nativeFilter = this.filter; nativeFilter = SimplifyingFilterVisitor.simplify(nativeFilter, nativeSchema); nativeFilter = reprojectFilter(nativeFilter); if (this.nativeSchema.getGeometryDescriptor() != null) { String defaultGeometryPName = this.nativeSchema.getGeometryDescriptor().getName() .getLocalPart(); RenamePropertyFilterVisitor renameBoundsVisitor = new RenamePropertyFilterVisitor( "@bounds", defaultGeometryPName); nativeFilter = (Filter) nativeFilter.accept(renameBoundsVisitor, null); } InReplacingFilterVisitor inreplacer = new InReplacingFilterVisitor(); nativeFilter = (Filter) nativeFilter.accept(inreplacer, null); return nativeFilter; }
public void testRegExFIDValidator() { FIDValidator validator = new SimplifyingFilterVisitor.RegExFIDValidator("abc\\.\\d+"); simpleVisitor.setFIDValidator(validator); Set<Identifier> ids = new HashSet<Identifier>(); ids.add(ff.featureId("abc..")); ids.add(ff.featureId(".abc.1")); ids.add(ff.featureId("abc.123")); ids.add(ff.featureId("abc.ax")); Id filter = ff.id(ids); Filter result = (Filter) filter.accept(simpleVisitor, null); Filter expected = ff.id(Collections.singleton(ff.featureId("abc.123"))); assertEquals(expected, result); }
public static Filter buildFilter(Selector selector, FeatureType targetFeatureType) { Filter filter = (Filter) selector.accept(INSTANCE); SimplifyingFilterVisitor simplifier = new UnboundSimplifyingFilterVisitor(); simplifier.setFeatureType(targetFeatureType); return (Filter) filter.accept(simplifier, null); } }