@Override public HashSet<String> getRequiredColumns() { return field.getRequiredColumns(); }
@Override public Filter apply(DimFilter input) { return input.toFilter(); } }
@Override public byte[] getCacheKey() { byte[] subKey = field.getCacheKey(); return ByteBuffer.allocate(1 + subKey.length).put(DimFilterUtils.NOT_CACHE_ID).put(subKey).array(); }
private DimFilter maybeOptimize(final DimFilter dimFilter) { if (dimFilter == null) { return null; } return optimize ? dimFilter.optimize() : dimFilter; }
@Override public RangeSet<String> getDimensionRangeSet(String dimension) { RangeSet<String> retSet = TreeRangeSet.create(); for (DimFilter field : fields) { RangeSet<String> rangeSet = field.getDimensionRangeSet(dimension); if (rangeSet == null) { return null; } else { retSet.addAll(rangeSet); } } return retSet; }
@Override public DimFilter optimize() { return new NotDimFilter(this.getField().optimize()); }
for (String dimension : dimensions) { Optional<RangeSet<String>> optFilterRangeSet = dimensionRangeCache .computeIfAbsent(dimension, d -> Optional.fromNullable(dimFilter.getDimensionRangeSet(d)));
/** * Convert a DimFilter to a Filter. * * @param dimFilter dimFilter * * @return converted filter, or null if input was null */ @Nullable public static Filter toFilter(@Nullable DimFilter dimFilter) { return dimFilter == null ? null : dimFilter.toFilter(); }
@Override public HashSet<String> getRequiredColumns() { HashSet<String> requiredColumns = new HashSet<>(); fields.forEach(field -> requiredColumns.addAll(field.getRequiredColumns())); return requiredColumns; }
@Override public Sequence<ScanResultValue> run(QueryPlus<ScanResultValue> queryPlus, Map<String, Object> responseContext) { ScanQuery scanQuery = (ScanQuery) queryPlus.getQuery(); if (scanQuery.getFilter() != null) { scanQuery = scanQuery.withDimFilter(scanQuery.getFilter().optimize()); queryPlus = queryPlus.withQuery(scanQuery); } return runner.run(queryPlus, responseContext); } };
public byte[] getCacheKey() { final byte[] filterBytes = dimFilter == null ? ByteArrays.EMPTY_ARRAY : dimFilter.getCacheKey(); final byte[] boundBytes = StringUtils.toUtf8(bound); final byte delimiter = (byte) 0xff; return ByteBuffer.allocate(2 + boundBytes.length + filterBytes.length) .put(CACHE_TYPE_ID) .put(boundBytes) .put(delimiter) .put(filterBytes) .array(); }
@Override public RangeSet<String> getDimensionRangeSet(String dimension) { RangeSet<String> retSet = null; for (DimFilter field : fields) { RangeSet<String> rangeSet = field.getDimensionRangeSet(dimension); if (rangeSet != null) { if (retSet == null) { retSet = TreeRangeSet.create(rangeSet); } else { retSet.removeAll(rangeSet.complement()); } } } return retSet; }
@Override public Filter toFilter() { return new NotFilter(field.toFilter()); }
@Override public HashSet<String> getRequiredColumns() { HashSet<String> requiredColumns = new HashSet<>(); fields.forEach(field -> requiredColumns.addAll(field.getRequiredColumns())); return requiredColumns; }
@Override public Sequence<Result<SearchResultValue>> run( QueryPlus<Result<SearchResultValue>> queryPlus, Map<String, Object> responseContext ) { SearchQuery searchQuery = (SearchQuery) queryPlus.getQuery(); if (searchQuery.getDimensionsFilter() != null) { searchQuery = searchQuery.withDimFilter(searchQuery.getDimensionsFilter().optimize()); queryPlus = queryPlus.withQuery(searchQuery); } return runner.run(queryPlus, responseContext); } },
static byte[] computeCacheKey(byte cacheIdKey, List<DimFilter> filters) { if (filters.size() == 1) { return filters.get(0).getCacheKey(); } byte[][] cacheKeys = new byte[filters.size()][]; int totalSize = 0; int index = 0; for (DimFilter field : filters) { cacheKeys[index] = field.getCacheKey(); totalSize += cacheKeys[index].length; ++index; } ByteBuffer retVal = ByteBuffer.allocate(1 + totalSize); retVal.put(cacheIdKey); for (byte[] cacheKey : cacheKeys) { retVal.put(cacheKey); } return retVal.array(); }
/** * 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(); }
private Sequence<Cursor> makeCursors(IncrementalIndexStorageAdapter sa, DimFilter filter) { return sa.makeCursors( filter.toFilter(), schemaInfo.getDataInterval(), VirtualColumns.EMPTY, Granularities.ALL, false, null ); }
private static Set<String> extractFieldsFromAggregations(List<AggregatorFactory> aggs) { Set<String> ret = new HashSet<>(); for (AggregatorFactory agg : aggs) { if (agg instanceof FilteredAggregatorFactory) { FilteredAggregatorFactory fagg = (FilteredAggregatorFactory) agg; ret.addAll(fagg.getFilter().getRequiredColumns()); } ret.addAll(agg.requiredFields()); } return ret; }