TblColRef col = compareFilter.getColumn(); Collection<String> constValues = (Collection<String>) compareFilter.getValues(); if (constValues == null || constValues.isEmpty()) { return filter; CompareTupleFilter newCompareFilter = new CompareTupleFilter(compareFilter.getOperator()); newCompareFilter.addChild(new ColumnTupleFilter(col));
@SuppressWarnings({ "unchecked", "rawtypes" }) private TupleFilter translateCompareTupleFilter(CompareTupleFilter compTupleFilter) { if (compTupleFilter.getFunction() == null || (!(compTupleFilter.getFunction() instanceof BuiltInFunctionTupleFilter))) return null; BuiltInFunctionTupleFilter builtInFunctionTupleFilter = (BuiltInFunctionTupleFilter) compTupleFilter.getFunction(); CompareTupleFilter translated = new CompareTupleFilter(builtInFunctionTupleFilter.isReversed() ? FilterOperatorEnum.NOTIN : FilterOperatorEnum.IN); translated.addChild(new ColumnTupleFilter(columnRef)); Object computedVal = builtInFunctionTupleFilter.invokeFunction(dictVal); Class clazz = Primitives.wrap(computedVal.getClass()); Object targetVal = compTupleFilter.getFirstValue(); if (Primitives.isWrapperType(clazz)) targetVal = clazz.cast(clazz.getDeclaredMethod("valueOf", String.class).invoke(null, compTupleFilter.getFirstValue())); switch (compTupleFilter.getOperator()) { case EQ: compResult = comp == 0; break; case IN: compResult = compTupleFilter.getValues().contains(computedVal.toString()); break; case NOTIN: compResult = !compTupleFilter.getValues().contains(computedVal.toString()); break; default: translated.addChild(new ConstantTupleFilter(inValues));
protected CompareTupleFilter buildCompareDynamicFilter(List<TblColRef> groups, FilterOperatorEnum operator) { CompareTupleFilter compareFilter = new CompareTupleFilter(operator); compareFilter.addChild(new ColumnTupleFilter(groups.get(0))); compareFilter.addChild(new DynamicTupleFilter("?0")); compareFilter.bindVariable("?0", "abc"); return compareFilter; }
private TupleFilter newCompareFilter(TupleFilter.FilterOperatorEnum op, TblColRef col) { CompareTupleFilter r = new CompareTupleFilter(op); r.addChild(new ColumnTupleFilter(col)); return r; }
private CompareTupleFilter(CompareTupleFilter another) { super(new ArrayList<TupleFilter>(another.children), another.operator); this.column = another.column; this.firstCondValue = another.getFirstValue(); this.function = another.getFunction(); this.conditionValues = new HashSet<Object>(); this.conditionValues.addAll(another.conditionValues); this.dynamicVariables = new HashMap<String, Object>(); this.dynamicVariables.putAll(another.dynamicVariables); }
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; }
if (child.getOperator() == TupleFilter.FilterOperatorEnum.EQ) { CompareTupleFilter compFilter = (CompareTupleFilter) child; TblColRef column = compFilter.getColumn(); if (column != null) { Pair<Set<Object>, Map<String, Object>> tmpValue = inColumnMap.get(column); tmpValue.getFirst().addAll(compFilter.getValues()); tmpValue.getSecond().putAll(compFilter.getVariables()); continue; ret.addChildren(extraFilters); for (Map.Entry<TblColRef, Pair<Set<Object>, Map<String, Object>>> entry : inColumnMap.entrySet()) { CompareTupleFilter inFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.IN); inFilter.addChild(new ColumnTupleFilter(entry.getKey())); inFilter.addChild(new ConstantTupleFilter(entry.getValue().getFirst())); inFilter.getVariables().putAll(entry.getValue().getSecond()); ret.addChild(inFilter);
private TupleFilter translateFunctionTupleFilter(BuiltInFunctionTupleFilter builtInFunctionTupleFilter) { if (!builtInFunctionTupleFilter.isValid()) return null; TblColRef columnRef = builtInFunctionTupleFilter.getColumn(); Dictionary<?> dict = dimEncMap.getDictionary(columnRef); if (dict == null) return null; CompareTupleFilter translated = new CompareTupleFilter(builtInFunctionTupleFilter.isReversed() ? FilterOperatorEnum.NOTIN : FilterOperatorEnum.IN); translated.addChild(new ColumnTupleFilter(columnRef)); try { int translatedInClauseMaxSize = KylinConfig.getInstanceFromEnv().getTranslatedInClauseMaxSize(); for (int i = dict.getMinId(); i <= dict.getMaxId(); i++) { Object dictVal = dict.getValueFromId(i); if ((Boolean) builtInFunctionTupleFilter.invokeFunction(dictVal)) { translated.addChild(new ConstantTupleFilter(dictVal)); if (translated.getChildren().size() > translatedInClauseMaxSize) { return null; } } } logger.debug("getting a in clause with {} children", translated.getChildren().size()); } catch (Exception e) { logger.debug(e.getMessage()); return null; } return translated; }
if (comp.getChildren().size() > 1 && !(comp.getChildren().get(1) instanceof ConstantTupleFilter)) return true; TblColRef col = comp.getColumn(); DataTypeOrder order = col.getType().getOrder(); String filterVal = toString(comp.getFirstValue()); switch (comp.getOperator()) { case EQ: case IN: String filterMin = order.min((Set<String>) comp.getValues()); String filterMax = order.max((Set<String>) comp.getValues()); return order.compare(filterMin, maxVal) <= 0 && order.compare(minVal, filterMax) <= 0; case LT:
@Test public void basicTest() { TableDesc t1 = TableDesc.mockup("DEFAULT.TEST_KYLIN_FACT"); TblColRef column = TblColRef.mockup(t1, 2, "CAL_DT", "date"); CompareTupleFilter compareFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.EQ); ColumnTupleFilter columnFilter = new ColumnTupleFilter(column); compareFilter.addChild(columnFilter); ConstantTupleFilter constantFilter = null; constantFilter = new ConstantTupleFilter("946684800000"); compareFilter.addChild(constantFilter); TimeConditionLiteralsReplacer filterDecorator = new TimeConditionLiteralsReplacer(compareFilter); byte[] bytes = TupleFilterSerializer.serialize(compareFilter, filterDecorator, DictCodeSystem.INSTANCE); CompareTupleFilter compareTupleFilter = (CompareTupleFilter) TupleFilterSerializer.deserialize(bytes, DictCodeSystem.INSTANCE); Assert.assertEquals("2000-01-01", compareTupleFilter.getFirstValue()); } }
@Override public TupleFilter copy() { return new CompareTupleFilter(this); }
private void findMustEqualColsAndValues(TupleFilter filter, Collection<TblColRef> lookingForCols, HashMap<TblColRef, Object> result) { if (filter instanceof CompareTupleFilter) { CompareTupleFilter comp = (CompareTupleFilter) filter; TblColRef col = comp.getColumn(); if (lookingForCols.contains(col)) { if (comp.getOperator() == FilterOperatorEnum.EQ) result.put(col, comp.getFirstValue()); else if (comp.getOperator() == FilterOperatorEnum.ISNULL) result.put(col, null); } return; } if (filter instanceof LogicalTupleFilter) { LogicalTupleFilter logic = (LogicalTupleFilter) filter; if (logic.getOperator() == FilterOperatorEnum.AND) { for (TupleFilter child : logic.getChildren()) findMustEqualColsAndValues(child, lookingForCols, result); } return; } }
public static CompareTupleFilter compare(TblColRef col, TupleFilter.FilterOperatorEnum op, int... ids) { CompareTupleFilter filter = new CompareTupleFilter(op); filter.setNullString(idToStr(Dictionary.NULL_ID[1])); filter.addChild(columnFilter(col)); for (int i : ids) { filter.addChild(constFilter(i)); } return filter; }
private ConciseSet evalCompareLTE(CompareTupleFilter filter) { int id = Dictionary.stringToDictId(filter.getFirstValue()); return collectRange(filter.getColumn(), null, id); }
/** * replace filter on timestamp column to null, so that two tuple filter trees can * be compared regardless of the filter condition on timestamp column (In top level where conditions concatenated by ANDs) * @param filter * @return */ @Override public TupleFilter onSerialize(TupleFilter filter) { if (filter == null) return null; //we just need reference equal if (root == filter) { isInTopLevelANDs.put(filter, true); } if (isInTopLevelANDs.containsKey(filter)) { classifyChildrenByMarking(filter); if (filter instanceof CompareTupleFilter) { TblColRef c = ((CompareTupleFilter) filter).getColumn(); if (c != null && c.equals(tsColumn)) { return null; } } } 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 ConciseSet evalCompareIn(CompareTupleFilter filter) { ConciseSet set = new ConciseSet(); for (String value : filter.getValues()) { int id = Dictionary.stringToDictId(value); ConciseSet bitMap = provider.getBitMap(filter.getColumn(), id, id); if (bitMap == null) return null; set.addAll(bitMap); } return set; }
private TupleFilter getMockFilter2() { LogicalTupleFilter ret = new LogicalTupleFilter(TupleFilter.FilterOperatorEnum.OR); TblColRef colRef = TblColRef.newInnerColumn("DEFAULT.TEST_KYLIN_FACT.LSTG_FORMAT_NAME", TblColRef.InnerDataTypeEnum.LITERAL); ret.addChildren(getCompareEQFilter(colRef, "ABIN")); ret.addChildren(getCompareEQFilter(colRef, "Auction")); CompareTupleFilter notInFilter = new CompareTupleFilter(TupleFilter.FilterOperatorEnum.NOTIN); notInFilter.addChildren(getCompareEQFilter(colRef, "Auction", "Others")); ret.addChildren(notInFilter); return 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; }
@Override public void deserialize(IFilterCodeSystem<?> cs, ByteBuffer buffer) { this.dynamicVariables.clear(); int size = BytesUtil.readVInt(buffer); for (int i = 0; i < size; i++) { String name = BytesUtil.readUTFString(buffer); Object value = cs.deserialize(buffer); bindVariable(name, value); } }