public FrozenRollUpStructure freeze(Time time) { return new FrozenRollUpStructure(layers, layerMap, time); } }
public FrozenRollUpStructure(List<GranularityLayer> layers, Time timestamp) { super(layers); time = timestamp; initFrozenLayers(); }
public boolean containsTimeAtGranularity(Time t, Granularity g) { return getFrozenLayer(g).getTotalRange().contains(t); }
private void initFrozenLayers() { this.layersAscending = new ArrayList<FrozenGranularityLayer>(); this.layersDescending = new LinkedList<FrozenGranularityLayer>(); this.frozenLayers = new HashMap<Granularity, FrozenGranularityLayer>(); FrozenGranularityLayer child = null; for (GranularityLayer layer : getLayers()) { FrozenGranularityLayer frozen = new FrozenGranularityLayer(layer, child, time); frozenLayers.put(layer.getGranularity(), frozen); layersAscending.add(frozen); layersDescending.add(0, frozen); child = frozen; } }
/** * Returns a list of contiguous time ranges, which fully encapsulate the given * range, provided the range is within the total range of the rollup structure. * * In cases where the rollup structure cannot fully encompass the given range, * as much of the rollup structure as possible will be used to cover the range. * * The resulting ranges are all of the same duration (the largest granularity). */ List<TimeRange> getEncompassingRanges(TimeRange range) { List<FrozenGranularityLayer> l = struct.getFrozenLayers(); FrozenGranularityLayer largest = l.get(l.size() - 1); TimeRange fillRange = range.augmentToOverlapWith(largest.getGranularity()); return largest.fillRange(fillRange); } }
public boolean canHoldValueAt(TimeMemberKey timeKey) { return structFactory.getStructure().containsTimeAtGranularity(timeKey.getStart(), timeKey.getGranularity()); }
List<TimeRange> getRanges(InsightCAddress addr, TimeRange range, int minCells) { FuzzyTimeRangeExpander expander = expanderFactory.makeExpander(); FrozenRollUpStructure struct = expander.getStructure(); Time now = struct.getTime(); FuzzyTimeRange fuzzyRange = makeFuzzyRange(range, now, minCells); List<TimeRange> ranges = expander.expand(fuzzyRange); if (minCells > 1) { ranges = splitterFactory.makeSplitter(struct, fuzzyRange, minCells).split(ranges); } return ranges; }
for (TimeRange range: ranges) { Granularity gran = range.getDurationAsGranularity(); FrozenGranularityLayer layer = struct.getFrozenLayer(gran); toProcess.add(layer.getCell(range));
/** * Returns the smallest layer which should be used to make a query for minCells across the given range. */ public GranularityLayer findSmallestUsableLayer(FrozenRollUpStructure struct, FuzzyTimeRange range, int minCells) { Granularity requiredGran = Granularity.inNanos(range.getIn().getDuration() / minCells); GranularityLayer useLayer = null; for (GranularityLayer layer : struct.getLayers()) { Granularity layerGran = layer.getGranularity(); if (layerGran.isBiggerThan(requiredGran)) { break; } else { useLayer = layer; } } if (useLayer == null) { return struct.getLayers().get(0); } return useLayer; } }
/** * Returns a map from granularity to the oldest datapoint which should * exist for it. */ GranularityTimes getOldestAllowedTimeForGranularity() { Time now = timeSvc.nowNanoTime(); FrozenRollUpStructure frozenStruct = this.struct.freeze(now); GranularityTimes res = new GranularityTimes(); for (FrozenGranularityLayer layer : frozenStruct.getFrozenLayers()) { res.put(layer.getGranularity(), layer.getTotalRange().getStartTime()); } return res; }
FrozenGranularityLayer largestLayer = struct.getFrozenLayer(largestGran); List<FrozenCell> toProcess = new LinkedList<FrozenCell>(); for (TimeRange root : roots) {
FrozenRollUpStructure(List<GranularityLayer> layers, Map<Granularity, GranularityLayer> layerMap, Time timestamp) { super(layers, layerMap); time = timestamp; initFrozenLayers(); }