private void classifyChildrenByMarking(TupleFilter filter) { if (filter instanceof LogicalTupleFilter) { if (filter.getOperator() == TupleFilter.FilterOperatorEnum.AND) { for (TupleFilter child : filter.getChildren()) { isInTopLevelANDs.put(child, true); } } } } }
protected TupleFilter flattenToOrAndFilter(TupleFilter filter) { if (filter == null) return null; TupleFilter flatFilter = filter.flatFilter(); // normalize to OR-AND filter if (flatFilter.getOperator() == TupleFilter.FilterOperatorEnum.AND) { LogicalTupleFilter f = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); f.addChild(flatFilter); flatFilter = f; } if (flatFilter.getOperator() != TupleFilter.FilterOperatorEnum.OR) throw new IllegalStateException(); return flatFilter; }
protected List<Collection<ColumnRange>> translateToOrAndDimRanges(TupleFilter flatFilter) { List<Collection<ColumnRange>> result = Lists.newArrayList(); if (flatFilter == null) { result.add(Collections.<ColumnRange> emptyList()); return result; } for (TupleFilter andFilter : flatFilter.getChildren()) { if (andFilter.getOperator() != TupleFilter.FilterOperatorEnum.AND) throw new IllegalStateException("Filter should be AND instead of " + andFilter); Collection<ColumnRange> andRanges = translateToAndDimRanges(andFilter.getChildren()); if (andRanges != null) { result.add(andRanges); } } return preEvaluateConstantConditions(result); }
private void findMustTrueCompareFilters(TupleFilter filter, Set<CompareTupleFilter> result) { if (filter instanceof CompareTupleFilter) { if (((CompareTupleFilter) filter).getColumn() != null) { result.add((CompareTupleFilter) filter); } return; } if (filter instanceof LogicalTupleFilter) { if (filter.getOperator() == FilterOperatorEnum.AND) { for (TupleFilter child : filter.getChildren()) { findMustTrueCompareFilters(child, result); } } return; } }
protected Set<CompareTupleFilter> findSingleValuesCompFilters(TupleFilter filter) { Collection<? extends TupleFilter> toCheck; if (filter instanceof CompareTupleFilter) { toCheck = Collections.singleton(filter); } else if (filter instanceof LogicalTupleFilter && filter.getOperator() == FilterOperatorEnum.AND) { toCheck = filter.getChildren(); } else { return Collections.emptySet(); } Set<CompareTupleFilter> result = Sets.newHashSet(); for (TupleFilter f : toCheck) { if (f instanceof CompareTupleFilter) { CompareTupleFilter compFilter = (CompareTupleFilter) f; // is COL=const ? if (compFilter.getOperator() == FilterOperatorEnum.EQ && compFilter.getValues().size() == 1 && compFilter.getColumn() != null) { result.add(compFilter); } } } return result; }
private TupleFilter replaceChildren(TupleFilter filter, List<TupleFilter> newChildren) { if (filter instanceof LogicalTupleFilter) { LogicalTupleFilter r = new LogicalTupleFilter(filter.getOperator()); r.addChildren(newChildren); return r; } else if (filter instanceof CaseTupleFilter) { CaseTupleFilter r = new CaseTupleFilter(); r.addChildren(newChildren); return r; } else { throw new IllegalStateException("Cannot replaceChildren on " + filter); } }
private TupleFilter and(TupleFilter f1, TupleFilter f2) { if (f1 == null) return f2; if (f2 == null) return f1; if (f1.getOperator() == FilterOperatorEnum.AND) { f1.addChild(f2); return f1; } if (f2.getOperator() == FilterOperatorEnum.AND) { f2.addChild(f1); return f2; } LogicalTupleFilter and = new LogicalTupleFilter(FilterOperatorEnum.AND); and.addChild(f1); and.addChild(f2); return and; }
List<TupleFilter> extraFilters = Lists.newLinkedList(); for (TupleFilter child : children) { if (child.getOperator() == TupleFilter.FilterOperatorEnum.EQ) { CompareTupleFilter compFilter = (CompareTupleFilter) child; TblColRef column = compFilter.getColumn();
private static void serializeFilter(int flag, TupleFilter filter, ByteBuffer buffer, IFilterCodeSystem<?> cs) { if (flag < 0) { BytesUtil.writeVInt(-1, buffer); } else { int opVal = filter.getOperator().getValue(); BytesUtil.writeVInt(opVal, buffer); filter.serialize(cs, buffer); BytesUtil.writeVInt(flag, buffer); } }
private TupleFilter removeNotInternal(TupleFilter filter) { FilterOperatorEnum op = filter.getOperator(); if (!(filter instanceof LogicalTupleFilter)) { return filter; } LogicalTupleFilter logicalFilter = (LogicalTupleFilter) filter; switch (logicalFilter.operator) { case NOT: assert (filter.children.size() == 1); TupleFilter reverse = filter.children.get(0).reverse(); return removeNotInternal(reverse); case AND: LogicalTupleFilter andFilter = new LogicalTupleFilter(FilterOperatorEnum.AND); for (TupleFilter child : logicalFilter.children) { andFilter.addChild(removeNotInternal(child)); } return andFilter; case OR: LogicalTupleFilter orFilter = new LogicalTupleFilter(FilterOperatorEnum.OR); for (TupleFilter child : logicalFilter.children) { orFilter.addChild(removeNotInternal(child)); } return orFilter; default: throw new IllegalStateException("This filter is unexpected: " + filter); } }
FilterOperatorEnum op = filter.getOperator(); List<TupleFilter> andChildren = new LinkedList<TupleFilter>(); List<TupleFilter> orChildren = new LinkedList<TupleFilter>(); for (TupleFilter child : filter.getChildren()) { TupleFilter flatChild = flattenInternal(child, maxFlatChildrenSize); FilterOperatorEnum childOp = flatChild.getOperator(); if (childOp == FilterOperatorEnum.AND) { andChildren.add(flatChild);
@Override public TupleFilter onSerialize(TupleFilter filter) { if (filter == null) return null; // In case of NOT(unEvaluatableFilter), we should immediately replace it as TRUE, // Otherwise, unEvaluatableFilter will later be replace with TRUE and NOT(unEvaluatableFilter) // will always return FALSE. if (filter.getOperator() == FilterOperatorEnum.NOT && !TupleFilter.isEvaluableRecursively(filter)) { TupleFilter.collectColumns(filter, unevaluatableColumnCollector); return ConstantTupleFilter.TRUE; } // shortcut for unEvaluatable filter if (!filter.isEvaluable()) { TupleFilter.collectColumns(filter, unevaluatableColumnCollector); return ConstantTupleFilter.TRUE; } // map to column onto grid table if (colMapping != null && filter instanceof ColumnTupleFilter) { ColumnTupleFilter colFilter = (ColumnTupleFilter) filter; int gtColIdx = mapCol(colFilter.getColumn()); return new ColumnTupleFilter(info.colRef(gtColIdx)); } // encode constants if (useEncodeConstants && filter instanceof CompareTupleFilter) { return encodeConstants((CompareTupleFilter) filter); } return filter; }
private TupleFilter flattenToOrAndFilter(TupleFilter filter) { if (filter == null) return null; TupleFilter flatFilter = filter.flatFilter(); // normalize to OR-AND filter if (flatFilter.getOperator() == FilterOperatorEnum.AND) { LogicalTupleFilter f = new LogicalTupleFilter(FilterOperatorEnum.OR); f.addChild(flatFilter); flatFilter = f; } if (flatFilter.getOperator() != FilterOperatorEnum.OR) throw new IllegalStateException(); return flatFilter; }
private TupleFilter replaceChildren(TupleFilter filter, List<TupleFilter> newChildren) { if (filter instanceof LogicalTupleFilter) { LogicalTupleFilter r = new LogicalTupleFilter(filter.getOperator()); r.addChildren(newChildren); return r; } else throw new IllegalStateException("Cannot replaceChildren on " + filter); }
if (filter.getOperator() == TupleFilter.FilterOperatorEnum.AND) { Range<Long> ret = Range.all(); for (TupleFilter child : filter.getChildren()) {
private List<Collection<ColumnValueRange>> translateToOrAndDimRanges(TupleFilter flatFilter, CubeSegment cubeSegment) { List<Collection<ColumnValueRange>> result = Lists.newArrayList(); if (flatFilter == null) { result.add(Collections.<ColumnValueRange> emptyList()); return result; } for (TupleFilter andFilter : flatFilter.getChildren()) { if (andFilter.getOperator() != FilterOperatorEnum.AND) { throw new IllegalStateException("Filter should be AND instead of " + andFilter); } Collection<ColumnValueRange> andRanges = translateToAndDimRanges(andFilter.getChildren(), cubeSegment); result.add(andRanges); } return preprocessConstantConditions(result); }
if (filter instanceof CompareTupleFilter) { toCheck = Collections.singleton(filter); } else if (filter instanceof LogicalTupleFilter && filter.getOperator() == FilterOperatorEnum.AND) { toCheck = filter.getChildren(); } else {
FilterOperatorEnum op = filter.getOperator(); List<TupleFilter> andChildren = new LinkedList<TupleFilter>(); List<TupleFilter> orChildren = new LinkedList<TupleFilter>(); for (TupleFilter child : filter.getChildren()) { TupleFilter flatChild = flattenInternal(child); FilterOperatorEnum childOp = flatChild.getOperator(); if (childOp == FilterOperatorEnum.AND) { andChildren.add(flatChild);
private static void serializeFilter(int flag, TupleFilter filter, Decorator decorator, ByteBuffer buffer) { if (flag < 0) { BytesUtil.writeVInt(-1, buffer); } else { byte[] bytes = filter.serialize(); int opVal = filter.getOperator().getValue(); BytesUtil.writeVInt(opVal, buffer); BytesUtil.writeByteArray(bytes, buffer); BytesUtil.writeVInt(flag, buffer); } }
if (filter.getOperator() == FilterOperatorEnum.NOT && !TupleFilter.isEvaluableRecursively(filter)) { TupleFilter.collectColumns(filter, unstrictlyFilteredColumns); return ConstantTupleFilter.TRUE;