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; }
/** * 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); }
private Filter simplify(Filter filter) { return (Filter) filter.accept(new SimplifyingFilterVisitor(), null); }
new DuplicatingStyleVisitor() { SimplifyingFilterVisitor simplifier = new SimplifyingFilterVisitor();
SimplifyingFilterVisitor sfv = new SimplifyingFilterVisitor(); serverFilter = (Filter) serverFilter.accept(sfv, 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(); }
public Measure(Expression unscaled, Unit<Length> defaultUnit) { this.expression = unscaled; setDefaultUnit(defaultUnit); this.uom = defaultUnit; if (unscaled instanceof Literal) { processLiteralExpression((Literal) unscaled, defaultUnit); } else { // see if we can still optimize PropertyIsNull test = ff.isNull(unscaled); Filter simplified = (Filter) test.accept(new SimplifyingFilterVisitor(), null); if (simplified == Filter.INCLUDE) { // special case, the expression was nil to start with this.expression = NilExpression.NIL; this.uom = defaultUnit; } else if (simplified instanceof PropertyIsNull) { PropertyIsNull pin = (PropertyIsNull) simplified; Expression se = pin.getExpression(); if (se instanceof Literal) { processLiteralExpression((Literal) se, defaultUnit); } else { this.expression = se; this.uom = defaultUnit; } } } }
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; }
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); }
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 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); }
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 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); }
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); }
@Test public void testSimplifyRedundant() { PropertyIsBetween between = ff.between(ff.property("a"), ff.property("b"), ff.property("c")); PropertyIsEqualTo equal = ff.equal(ff.property("a"), ff.property("b"), false); And and = ff.and(between, equal); NullHandlingVisitor nh = new NullHandlingVisitor(); Filter nhResult = (Filter) and.accept(nh, null); SimplifyingFilterVisitor simplifier = new SimplifyingFilterVisitor(); Filter simplified = (Filter) nhResult.accept(simplifier, null); assertTrue(simplified instanceof And); Filter expected = ff.and( Arrays.asList( between, equal, propertyNotNull("a"), propertyNotNull("b"), propertyNotNull("c"))); assertEquals(expected, simplified); }