public ArcSdeSimplifyingFilterVisitor(SimpleFeatureType schema) { super.setFeatureType(schema); }
/** * 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); }
new SimplifyingFilterVisitor.TypeNameDotNumberFidValidator(typeName); filterSimplifier.setFIDValidator(validator); filterSimplifier.setFeatureType(this.featureType);
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 <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); }
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; }
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 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); }
simplifier.setFeatureType(source.getSchema()); Filter simplifiedFilter = (Filter) query.getFilter().accept(simplifier, null); query.setFilter(simplifiedFilter);
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 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 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 testOrPseudoBetween(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); // (a > min && a <= max) or (a <= min) Filter original = ff.or( Arrays.asList( // ff.and( ff.greater(ff.property("a"), ff.literal(min)), // ff.lessOrEqual(ff.property("a"), ff.literal(max))), // ff.lessOrEqual(ff.property("a"), ff.literal(min)))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals(ff.lessOrEqual(ff.property("a"), ff.literal(max)), simplified); }
private <T> void testAndOverlappingRanges(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.greater(ff.property("a"), ff.literal(min)), // ff.less(ff.property("a"), ff.literal(max)), // ff.less(ff.property("a"), ff.literal(mid)))); Filter simplified = (Filter) original.accept(visitor, null); assertEquals( ff.and( ff.greater(ff.property("a"), ff.literal(min)), // ff.less(ff.property("a"), ff.literal(mid))), simplified); }
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); }
public static Selector combineAnd(List<Data> selectors, Object ctx) { if (selectors.size() == 1) { return selectors.get(0); } List<Filter> filters = new ArrayList<>(); FeatureType featureType = null; for (Data selector : selectors) { filters.add(selector.filter); featureType = selector.featureType; } org.opengis.filter.And and = FF.and(filters); SimplifyingFilterVisitor visitor; if (ctx instanceof SimplifyingFilterVisitor) { visitor = (SimplifyingFilterVisitor) ctx; } else { visitor = new UnboundSimplifyingFilterVisitor(); visitor.setFeatureType(featureType); } Filter simplified = (Filter) and.accept(visitor, null); if (Filter.INCLUDE.equals(simplified)) { return ACCEPT; } else if (Filter.EXCLUDE.equals(simplified)) { return REJECT; } else { return new Data(simplified); } }
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); } }
simplifier.setFeatureType(source.getSchema()); Filter simplifiedFilter = (Filter) query.getFilter().accept(simplifier, null); query.setFilter(simplifiedFilter);
simplifier.setFeatureType(source.getSchema()); Filter simplifiedFilter = (Filter) query.getFilter().accept(simplifier, null); query.setFilter(simplifiedFilter);