public static NotDimFilter not(DimFilter filter) { return new NotDimFilter(filter); }
@Override public DimFilter optimize() { return new NotDimFilter(this.getField().optimize()); }
private static int computeCost(final DimFilter filter) { if (filter instanceof NotDimFilter) { return computeCost(((NotDimFilter) filter).getField()); } else if (filter instanceof AndDimFilter) { int cost = 0; for (DimFilter field : ((AndDimFilter) filter).getFields()) { cost += computeCost(field); } return cost; } else if (filter instanceof OrDimFilter) { int cost = 0; for (DimFilter field : ((OrDimFilter) filter).getFields()) { cost += computeCost(field); } return cost; } else { return 1; } } }
/** * There are some special cases involving null that require special casing for And and Or instead of simply taking * the complement * * Example 1 : "NOT ( [0,INF) OR null)" The inside of NOT would evaluate to null, and the complement would also * be null. However, by breaking the NOT, this statement is "NOT([0,INF)) AND NOT(null)", which means it should * actually evaluate to (-INF, 0). * * Example 2 : "NOT ( [0,INF) AND null )" The inside of NOT would evaluate to [0,INF), and the complement would be * (-INF, 0). However the statement is actually "NOT([0,INF)) OR NOT(null)", and it should be evaluated to null. */ @Override public RangeSet<String> getDimensionRangeSet(String dimension) { if (field instanceof AndDimFilter) { List<DimFilter> fields = ((AndDimFilter) field).getFields(); return new OrDimFilter(Lists.transform(fields, NotDimFilter::new)).getDimensionRangeSet(dimension); } if (field instanceof OrDimFilter) { List<DimFilter> fields = ((OrDimFilter) field).getFields(); return new AndDimFilter(Lists.transform(fields, NotDimFilter::new)).getDimensionRangeSet(dimension); } if (field instanceof NotDimFilter) { return ((NotDimFilter) field).getField().getDimensionRangeSet(dimension); } RangeSet<String> rangeSet = field.getDimensionRangeSet(dimension); return rangeSet == null ? null : rangeSet.complement(); }
public static NotDimFilter NOT(DimFilter filter) { return new NotDimFilter(filter); }
private static DimFilter negate(final DimFilter filter) { if (Filtration.matchEverything().equals(filter)) { return Filtration.matchNothing(); } else if (Filtration.matchNothing().equals(filter)) { return Filtration.matchEverything(); } else if (filter instanceof NotDimFilter) { return ((NotDimFilter) filter).getField(); } else if (filter instanceof BoundDimFilter) { final BoundDimFilter negated = Bounds.not((BoundDimFilter) filter); return negated != null ? negated : new NotDimFilter(filter); } else { return new NotDimFilter(filter); } }
final DimFilter child = ((NotDimFilter) filter).getField(); final Pair<DimFilter, RangeSet<Long>> pair = extractConvertibleTimeBounds(child); if (pair.rhs != null && pair.lhs == null) {
return toFilter(plannerContext, rowSignature, Iterables.getOnlyElement(((RexCall) expression).getOperands())); } else if (kind == SqlKind.IS_FALSE || kind == SqlKind.IS_NOT_TRUE) { return new NotDimFilter( toFilter(plannerContext, rowSignature, Iterables.getOnlyElement(((RexCall) expression).getOperands())) ); } else { assert kind == SqlKind.NOT; return new NotDimFilter(Iterables.getOnlyElement(filters));
final DimFilter oldFilter = ((NotDimFilter) filter).getField(); final DimFilter newFilter = apply0(oldFilter); if (!oldFilter.equals(newFilter)) { return checkedProcess(new NotDimFilter(newFilter)); } else { return checkedProcess(filter);
@Override public DimFilter process(DimFilter filter) { if (filter instanceof AndDimFilter) { final List<DimFilter> children = getAndFilterChildren((AndDimFilter) filter); final DimFilter one = doSimplifyAnd(children); final DimFilter two = negate(doSimplifyOr(negateAll(children))); return computeCost(one) <= computeCost(two) ? one : two; } else if (filter instanceof OrDimFilter) { final List<DimFilter> children = getOrFilterChildren((OrDimFilter) filter); final DimFilter one = doSimplifyOr(children); final DimFilter two = negate(doSimplifyAnd(negateAll(children))); return computeCost(one) <= computeCost(two) ? one : two; } else if (filter instanceof NotDimFilter) { final DimFilter field = ((NotDimFilter) filter).getField(); final DimFilter candidate; if (field instanceof OrDimFilter) { candidate = doSimplifyAnd(negateAll(getOrFilterChildren((OrDimFilter) field))); } else if (field instanceof AndDimFilter) { candidate = doSimplifyOr(negateAll(getAndFilterChildren((AndDimFilter) field))); } else { candidate = negate(field); } return computeCost(filter) <= computeCost(candidate) ? filter : candidate; } else { return filter; } }
case NOT_EQUALS: return isAligned ? new NotDimFilter(Bounds.interval(boundRefKey, interval)) : Filtration.matchEverything(); case GREATER_THAN:
@Override public DimFilter optimize() { return new NotDimFilter(this.getField().optimize()); }
private static int computeCost(final DimFilter filter) { if (filter instanceof NotDimFilter) { return computeCost(((NotDimFilter) filter).getField()); } else if (filter instanceof AndDimFilter) { int cost = 0; for (DimFilter field : ((AndDimFilter) filter).getFields()) { cost += computeCost(field); } return cost; } else if (filter instanceof OrDimFilter) { int cost = 0; for (DimFilter field : ((OrDimFilter) filter).getFields()) { cost += computeCost(field); } return cost; } else { return 1; } } }
@Test public void testNotSelector() { assertFilterMatches( new NotDimFilter(new SelectorDimFilter("dim0", null, null)), ImmutableList.of("0", "1", "2", "3", "4", "5") ); assertFilterMatches( new NotDimFilter(new SelectorDimFilter("dim0", "", null)), ImmutableList.of("0", "1", "2", "3", "4", "5") ); assertFilterMatches( new NotDimFilter(new SelectorDimFilter("dim0", "0", null)), ImmutableList.of("1", "2", "3", "4", "5") ); assertFilterMatches( new NotDimFilter(new SelectorDimFilter("dim0", "1", null)), ImmutableList.of("0", "2", "3", "4", "5") ); } }
private static DimFilter negate(final DimFilter filter) { if (Filtration.matchEverything().equals(filter)) { return Filtration.matchNothing(); } else if (Filtration.matchNothing().equals(filter)) { return Filtration.matchEverything(); } else if (filter instanceof NotDimFilter) { return ((NotDimFilter) filter).getField(); } else if (filter instanceof BoundDimFilter) { final BoundDimFilter negated = Bounds.not((BoundDimFilter) filter); return negated != null ? negated : new NotDimFilter(filter); } else { return new NotDimFilter(filter); } }
/** * There are some special cases involving null that require special casing for And and Or instead of simply taking * the complement * * Example 1 : "NOT ( [0,INF) OR null)" The inside of NOT would evaluate to null, and the complement would also * be null. However, by breaking the NOT, this statement is "NOT([0,INF)) AND NOT(null)", which means it should * actually evaluate to (-INF, 0). * * Example 2 : "NOT ( [0,INF) AND null )" The inside of NOT would evaluate to [0,INF), and the complement would be * (-INF, 0). However the statement is actually "NOT([0,INF)) OR NOT(null)", and it should be evaluated to null. */ @Override public RangeSet<String> getDimensionRangeSet(String dimension) { if (field instanceof AndDimFilter) { List<DimFilter> fields = ((AndDimFilter) field).getFields(); return new OrDimFilter(Lists.transform(fields, NotDimFilter::new)).getDimensionRangeSet(dimension); } if (field instanceof OrDimFilter) { List<DimFilter> fields = ((OrDimFilter) field).getFields(); return new AndDimFilter(Lists.transform(fields, NotDimFilter::new)).getDimensionRangeSet(dimension); } if (field instanceof NotDimFilter) { return ((NotDimFilter) field).getField().getDimensionRangeSet(dimension); } RangeSet<String> rangeSet = field.getDimensionRangeSet(dimension); return rangeSet == null ? null : rangeSet.complement(); }
@Test public void testAggregateWithAndFilter() { final float[] values = {0.15f, 0.27f}; final TestFloatColumnSelector selector = new TestFloatColumnSelector(values); FilteredAggregatorFactory factory = new FilteredAggregatorFactory( new DoubleSumAggregatorFactory("billy", "value"), new AndDimFilter(Lists.newArrayList(new NotDimFilter(new SelectorDimFilter("dim", "b", null)), new SelectorDimFilter("dim", "a", null)))); validateFilteredAggs(factory, values, selector); }
final DimFilter oldFilter = ((NotDimFilter) filter).getField(); final DimFilter newFilter = apply0(oldFilter); if (!oldFilter.equals(newFilter)) { return checkedProcess(new NotDimFilter(newFilter)); } else { return checkedProcess(filter);
final DimFilter child = ((NotDimFilter) filter).getField(); final Pair<DimFilter, RangeSet<Long>> pair = extractConvertibleTimeBounds(child); if (pair.rhs != null && pair.lhs == null) {
@Test public void testAggregateWithNotFilter() { final float[] values = {0.15f, 0.27f}; final TestFloatColumnSelector selector = new TestFloatColumnSelector(values); FilteredAggregatorFactory factory = new FilteredAggregatorFactory( new DoubleSumAggregatorFactory("billy", "value"), new NotDimFilter(new SelectorDimFilter("dim", "b", null)) ); validateFilteredAggs(factory, values, selector); }