private void classifyChildrenByMarking(TupleFilter filter) { if (filter instanceof LogicalTupleFilter) { if (filter.getOperator() == TupleFilter.FilterOperatorEnum.AND) { for (TupleFilter child : filter.getChildren()) { isInTopLevelANDs.put(child, true); } } } } }
public static boolean containsMassInTupleFilter(TupleFilter filter) { if (filter == null) return false; if (filter instanceof MassInTupleFilter) { return true; } for (TupleFilter child : filter.getChildren()) { if (containsMassInTupleFilter(child)) return true; } return false; }
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 List<TupleFilter> cartesianProduct(List<TupleFilter> leftOrFilters, TupleFilter partialAndFilter, int maxFlatChildrenSize) { List<TupleFilter> oldProductFilters = new LinkedList<TupleFilter>(); oldProductFilters.add(partialAndFilter); for (TupleFilter orFilter : leftOrFilters) { List<TupleFilter> newProductFilters = new LinkedList<TupleFilter>(); for (TupleFilter orChildFilter : orFilter.getChildren()) { for (TupleFilter productFilter : oldProductFilters) { TupleFilter fullAndFilter = productFilter.copy(); fullAndFilter.addChildren(orChildFilter.getChildren()); newProductFilters.add(fullAndFilter); if (newProductFilters.size() > maxFlatChildrenSize) { throw new IllegalStateException("the filter is too large after do the flat, size=" + newProductFilters.size()); } } } oldProductFilters = newProductFilters; } return oldProductFilters; }
public static void collectColumns(TupleFilter filter, Set<TblColRef> collector) { if (filter == null || collector == null) return; if (filter instanceof ColumnTupleFilter) { ColumnTupleFilter columnTupleFilter = (ColumnTupleFilter) filter; collector.add(columnTupleFilter.getColumn()); } for (TupleFilter child : filter.getChildren()) { collectColumns(child, collector); } }
private void collectColumnsRecursively(TupleFilter filter, Set<TblColRef> collector) { if (filter == null) return; if (filter instanceof ColumnTupleFilter) { collector.add(((ColumnTupleFilter) filter).getColumn()); } for (TupleFilter child : filter.getChildren()) { collectColumnsRecursively(child, collector); } }
public static boolean isEvaluableRecursively(TupleFilter filter) { if (filter == null) return true; if (!filter.isEvaluable()) return false; for (TupleFilter child : filter.getChildren()) { if (!isEvaluableRecursively(child)) return false; } return true; }
@SuppressWarnings("unchecked") protected TupleFilter translateDerived(TupleFilter filter, Set<TblColRef> collector) { if (filter == null) return filter; if (filter instanceof CompareTupleFilter) { return translateDerivedInCompare((CompareTupleFilter) filter, collector); } List<TupleFilter> children = (List<TupleFilter>) filter.getChildren(); List<TupleFilter> newChildren = Lists.newArrayListWithCapacity(children.size()); boolean modified = false; for (TupleFilter child : children) { TupleFilter translated = translateDerived(child, collector); newChildren.add(translated); if (child != translated) modified = true; } if (modified) { filter = replaceChildren(filter, newChildren); } return filter; }
@Override public TupleFilter transform(TupleFilter tupleFilter) { TupleFilter translated = null; if (tupleFilter instanceof CompareTupleFilter) { //normal case translated = translateCompareTupleFilter((CompareTupleFilter) tupleFilter); if (translated != null) { logger.debug("Translated {{}} to IN clause. ", tupleFilter); } } else if (tupleFilter instanceof BuiltInFunctionTupleFilter) { //like,tolower case translated = translateFunctionTupleFilter((BuiltInFunctionTupleFilter) tupleFilter); if (translated != null) { logger.debug("Translated {{}} to IN clause. ", tupleFilter); } } else if (tupleFilter instanceof LogicalTupleFilter) { @SuppressWarnings("unchecked") ListIterator<TupleFilter> childIterator = (ListIterator<TupleFilter>) tupleFilter.getChildren().listIterator(); while (childIterator.hasNext()) { TupleFilter transformed = transform(childIterator.next()); if (transformed != null) { childIterator.set(transformed); } else { throw new IllegalStateException("Should not be null"); } } } return translated == null ? tupleFilter : translated; }
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 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 void compareFilter(TupleFilter f1, TupleFilter f2) { if (f1 == null && f2 == null) { return; } if (f1 == null || f2 == null) { throw new IllegalStateException("f1=" + f1 + ", f2=" + f2); } String str1 = f1.toString(); //System.out.println("f1=" + str1); String str2 = f2.toString(); //System.out.println("f2=" + str2); if (!str1.equals(str2)) { throw new IllegalStateException("f1=" + str1 + ", f2=" + str2); } int s1 = f1.getChildren().size(); int s2 = f2.getChildren().size(); if (s1 != s2) { throw new IllegalStateException("f1=" + str1 + ", f2=" + str2 + " has different children: " + s1 + " vs. " + s2); } for (int i = 0; i < s1; i++) { compareFilter(f1.getChildren().get(i), f2.getChildren().get(i)); } }
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(); flatFilter = new LogicalTupleFilter(FilterOperatorEnum.AND); for (TupleFilter andChild : andChildren) { flatFilter.addChildren(andChild.getChildren()); flatFilter = new LogicalTupleFilter(FilterOperatorEnum.OR); for (TupleFilter orChild : orChildren) { flatFilter.addChildren(orChild.getChildren()); throw new IllegalStateException("Filter is " + filter); if (flatFilter.getChildren() != null && flatFilter.getChildren().size() > maxFlatChildrenSize) { throw new IllegalStateException("the filter is too large after do the flat, size=" + flatFilter.getChildren().size());
@VisibleForTesting static TupleFilter mergeToInClause(TupleFilter filter) { List<? extends TupleFilter> children = filter.getChildren(); if (children.isEmpty()) { return filter; return ret.getChildren().size() == 1 ? ret.getChildren().get(0) : ret;
@SuppressWarnings("unchecked") @Override public TupleFilter onSerialize(TupleFilter filter) { if (filter instanceof CompareTupleFilter) { CompareTupleFilter cfilter = (CompareTupleFilter) filter; List<? extends TupleFilter> children = cfilter.getChildren(); if (children == null || children.size() < 1) { throw new IllegalArgumentException("Illegal compare filter: " + cfilter); } TblColRef col = cfilter.getColumn(); if (col == null || !col.getType().isDateTimeFamily()) { return cfilter; } for (TupleFilter child : filter.getChildren()) { dateCompareTupleChildren.put(child, col.getType()); } } if (filter instanceof ConstantTupleFilter && dateCompareTupleChildren.containsKey(filter)) { ConstantTupleFilter constantTupleFilter = (ConstantTupleFilter) filter; Set<String> newValues = Sets.newHashSet(); DataType columnType = dateCompareTupleChildren.get(filter); for (String value : (Collection<String>) constantTupleFilter.getValues()) { newValues.add(formatTime(value, columnType)); } return new ConstantTupleFilter(newValues); } return filter; }
private void bindVariable(TupleFilter filter, DataContext dataContext) { if (filter == null) { return; } for (TupleFilter childFilter : filter.getChildren()) { bindVariable(childFilter, dataContext); } if (filter instanceof CompareTupleFilter && dataContext != null) { CompareTupleFilter compFilter = (CompareTupleFilter) filter; for (Map.Entry<String, Object> entry : compFilter.getVariables().entrySet()) { String variable = entry.getKey(); Object value = dataContext.get(variable); if (value != null) { String str = value.toString(); if (compFilter.getColumn().getType().isDateTimeFamily()) str = String.valueOf(DateFormat.stringToMillis(str)); compFilter.clearPreviousVariableValues(variable); compFilter.bindVariable(variable, str); } } } } // ============================================================================
private static void internalSerialize(TupleFilter filter, Decorator decorator, ByteBuffer buffer, IFilterCodeSystem<?> cs) { if (decorator != null) { // give decorator a chance to manipulate the output filter filter = decorator.onSerialize(filter); } if (filter == null) { return; } if (filter.hasChildren()) { // serialize filter+true serializeFilter(1, filter, buffer, cs); // serialize children for (TupleFilter child : filter.getChildren()) { internalSerialize(child, decorator, buffer, cs); } // serialize none serializeFilter(-1, filter, buffer, cs); } else { // serialize filter+false serializeFilter(0, filter, buffer, cs); } }
@Test public void testMergeToInClause1() { TupleFilter originFilter = getMockFilter1(); TupleFilter resultFilter = TupleFilterVisitor.mergeToInClause(originFilter); Assert.assertNotNull(resultFilter); Assert.assertEquals(2, resultFilter.getChildren().size()); }
@Test public void testMergeToInClause2() { TupleFilter originFilter = getMockFilter2(); TupleFilter resultFilter = TupleFilterVisitor.mergeToInClause(originFilter); Assert.assertNotNull(resultFilter); Assert.assertEquals(2, resultFilter.getChildren().size()); }
if (filter.getOperator() == TupleFilter.FilterOperatorEnum.AND) { Range<Long> ret = Range.all(); for (TupleFilter child : filter.getChildren()) { Range childRange = extractTsConditionInternal(child, colRef); if (childRange != null) {