private LogicalTupleFilter logical(FilterOperatorEnum op, TupleFilter[] filters) { LogicalTupleFilter r = new LogicalTupleFilter(op); for (TupleFilter f : filters) r.addChild(f); return r; }
private LogicalTupleFilter logical(FilterOperatorEnum op, TupleFilter[] filters) { LogicalTupleFilter r = new LogicalTupleFilter(op); for (TupleFilter f : filters) r.addChild(f); return r; }
public static LogicalTupleFilter not(TupleFilter child) { LogicalTupleFilter r = new LogicalTupleFilter(FilterOperatorEnum.NOT); r.addChild(child); return r; }
@Override public TupleFilter reverse() { switch (operator) { case NOT: throw new IllegalStateException("NOT will be replaced in org.apache.kylin.query.relnode.OLAPFilterRel.TupleFilterVisitor"); case AND: case OR: LogicalTupleFilter reverse = new LogicalTupleFilter(REVERSE_OP_MAP.get(operator)); for (TupleFilter child : children) { reverse.addChild(child.reverse()); } return reverse; default: throw new IllegalStateException(); } }
public static LogicalTupleFilter logic(FilterOperatorEnum op, TupleFilter... children) { LogicalTupleFilter result = new LogicalTupleFilter(op); for (TupleFilter c : children) { result.addChild(c); } return result; }
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; }
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; }
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); } }
public TupleFilter buildOrFilter(List<TblColRef> columns) { CompareTupleFilter compareFilter1 = buildFilter1(columns.get(0)); CompareTupleFilter compareFilter2 = buildFilter2(columns.get(1)); LogicalTupleFilter logicFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); logicFilter.addChild(compareFilter1); logicFilter.addChild(compareFilter2); return logicFilter; } }
public TupleFilter buildAndFilter(List<TblColRef> columns) { CompareTupleFilter compareFilter1 = buildFilter1(columns.get(0)); CompareTupleFilter compareFilter2 = buildFilter2(columns.get(1)); LogicalTupleFilter andFilter = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.AND); andFilter.addChild(compareFilter1); andFilter.addChild(compareFilter2); return andFilter; }
protected TupleFilter buildAndFilter(List<TblColRef> columns) { CompareTupleFilter compareFilter1 = buildEQCompareFilter(columns, 0); CompareTupleFilter compareFilter2 = buildEQCompareFilter(columns, 1); LogicalTupleFilter andFilter = new LogicalTupleFilter(FilterOperatorEnum.AND); andFilter.addChild(compareFilter1); andFilter.addChild(compareFilter2); return andFilter; }
protected TupleFilter buildOrFilter(List<TblColRef> columns) { CompareTupleFilter compareFilter1 = buildEQCompareFilter(columns, 0); CompareTupleFilter compareFilter2 = buildEQCompareFilter(columns, 1); LogicalTupleFilter logicFilter = new LogicalTupleFilter(FilterOperatorEnum.OR); logicFilter.addChild(compareFilter1); logicFilter.addChild(compareFilter2); return logicFilter; }
@Test public void testSerialize10() { List<TblColRef> groups = buildGroups(); TupleFilter orFilter = buildOrFilter(groups); TupleFilter andFilter = buildAndFilter(groups); LogicalTupleFilter logicFilter = new LogicalTupleFilter(FilterOperatorEnum.OR); logicFilter.addChild(orFilter); logicFilter.addChild(andFilter); assertFilterSerDe(logicFilter); }
@Test public void testSerialize11() { List<TblColRef> groups = buildGroups(); TupleFilter orFilter = buildOrFilter(groups); TupleFilter andFilter = buildAndFilter(groups); LogicalTupleFilter logicFilter = new LogicalTupleFilter(FilterOperatorEnum.AND); logicFilter.addChild(orFilter); logicFilter.addChild(andFilter); assertFilterSerDe(logicFilter); }
private static LogicalTupleFilter buildRangeFilter(TblColRef[] hostCols, Set<Array<String>> satisfyingHostRecords) { int hn = hostCols.length; String[] min = new String[hn]; String[] max = new String[hn]; findMinMax(satisfyingHostRecords, hostCols, min, max); LogicalTupleFilter and = new LogicalTupleFilter(FilterOperatorEnum.AND); for (int i = 0; i < hn; i++) { CompareTupleFilter compMin = new CompareTupleFilter(FilterOperatorEnum.GTE); compMin.addChild(new ColumnTupleFilter(hostCols[i])); compMin.addChild(new ConstantTupleFilter(min[i])); and.addChild(compMin); CompareTupleFilter compMax = new CompareTupleFilter(FilterOperatorEnum.LTE); compMax.addChild(new ColumnTupleFilter(hostCols[i])); compMax.addChild(new ConstantTupleFilter(max[i])); and.addChild(compMax); } return and; }
private static TupleFilter buildInFilter(TblColRef[] hostCols, Set<Array<String>> satisfyingHostRecords) { if (satisfyingHostRecords.size() == 0) { return ConstantTupleFilter.FALSE; } int hn = hostCols.length; if (hn == 1) { CompareTupleFilter in = new CompareTupleFilter(FilterOperatorEnum.IN); in.addChild(new ColumnTupleFilter(hostCols[0])); in.addChild(new ConstantTupleFilter(asValues(satisfyingHostRecords))); return in; } else { LogicalTupleFilter or = new LogicalTupleFilter(FilterOperatorEnum.OR); for (Array<String> rec : satisfyingHostRecords) { LogicalTupleFilter and = new LogicalTupleFilter(FilterOperatorEnum.AND); for (int i = 0; i < hn; i++) { CompareTupleFilter eq = new CompareTupleFilter(FilterOperatorEnum.EQ); eq.addChild(new ColumnTupleFilter(hostCols[i])); eq.addChild(new ConstantTupleFilter(rec.data[i])); and.addChild(eq); } or.addChild(and); } return or; } }
public static LogicalTupleFilter logical(TupleFilter.FilterOperatorEnum op, TupleFilter... filters) { LogicalTupleFilter filter = new LogicalTupleFilter(op); for (TupleFilter f : filters) filter.addChild(f); return filter; }
protected TupleFilter buildAndFilter(List<TblColRef> columns) { CompareTupleFilter compareFilter1 = buildCompareFilter(columns, 0); CompareTupleFilter compareFilter2 = buildCompareFilter(columns, 1); LogicalTupleFilter andFilter = new LogicalTupleFilter(FilterOperatorEnum.AND); andFilter.addChild(compareFilter1); andFilter.addChild(compareFilter2); return andFilter; }
protected TupleFilter buildOrFilter(List<TblColRef> columns) { CompareTupleFilter compareFilter1 = buildCompareFilter(columns, 0); CompareTupleFilter compareFilter2 = buildCompareFilter(columns, 1); LogicalTupleFilter logicFilter = new LogicalTupleFilter(FilterOperatorEnum.OR); logicFilter.addChild(compareFilter1); logicFilter.addChild(compareFilter2); return logicFilter; }
@Test public void testSerialize11() { List<TblColRef> groups = buildGroups(); TupleFilter orFilter = buildOrFilter(groups); TupleFilter andFilter = buildAndFilter(groups); LogicalTupleFilter logicFilter = new LogicalTupleFilter(FilterOperatorEnum.AND); logicFilter.addChild(orFilter); logicFilter.addChild(andFilter); byte[] bytes = TupleFilterSerializer.serialize(logicFilter); TupleFilter newFilter = TupleFilterSerializer.deserialize(bytes); compareFilter(logicFilter, newFilter); }