@Override public DimFilter optimize() { return new NotDimFilter(this.getField().optimize()); }
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); } }
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; } } }
final DimFilter oldFilter = ((NotDimFilter) filter).getField(); final DimFilter newFilter = apply0(oldFilter); if (!oldFilter.equals(newFilter)) {
/** * 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(); }
final DimFilter child = ((NotDimFilter) filter).getField(); final Pair<DimFilter, RangeSet<Long>> pair = extractConvertibleTimeBounds(child); if (pair.rhs != null && pair.lhs == null) {
@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; } }
@Override public DimFilter optimize() { return new NotDimFilter(this.getField().optimize()); }
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); } }
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; } } }
final DimFilter oldFilter = ((NotDimFilter) filter).getField(); final DimFilter newFilter = apply0(oldFilter); if (!oldFilter.equals(newFilter)) {
/** * 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(); }
final DimFilter child = ((NotDimFilter) filter).getField(); final Pair<DimFilter, RangeSet<Long>> pair = extractConvertibleTimeBounds(child); if (pair.rhs != null && pair.lhs == null) {
@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; } }