List of usage examples for org.joda.time Interval withStart
public Interval withStart(ReadableInstant start)
From source file:com.addthis.basis.time.Dates.java
License:Apache License
/** * Truncate interval start and end by current time * (start/end values after current time are set to current time) * <p/>//from w w w . ja va 2 s.c o m * Truncate interval start by a specified number of period types * (eg. 30 days, 52 weeks, etc.) * <p/> * If type is null, no truncation is performed. * <p/> * When no truncation is performed, the input interval is returned * (this is useful for efficiently testing if truncation was performed). * * @param interval * @param limit number of TYPE periods above which interval should be truncated * @param type single field period type (the result of this method is undefined for multi-field period types) * @return */ public static Interval truncateInterval(Interval interval, int limit, PeriodType type) { Interval truncatedInterval = interval; if (type != null) { // Truncate end DateTime now = new DateTime(); if (interval.getEnd().isAfter(now)) { if (interval.getStart().isAfter(now)) { truncatedInterval = new Interval(now, now); } else { truncatedInterval = interval.withEnd(now); } } // Truncate start if (truncatedInterval.toPeriod(type).getValue(0) > --limit) { Period limitPeriod = period(limit, type); DateTime truncatedStart = truncatedInterval.getEnd().minus(limitPeriod); truncatedInterval = truncatedInterval.withStart(truncatedStart); } } return truncatedInterval; }
From source file:com.metamx.druid.index.v1.IncrementalIndexStorageAdapter.java
License:Open Source License
@Override public Iterable<Cursor> makeCursors(final Filter filter, final Interval interval, final QueryGranularity gran) { Interval actualIntervalTmp = interval; Interval dataInterval = getInterval(); if (!actualIntervalTmp.overlaps(dataInterval)) { return ImmutableList.of(); }/*from w w w. jav a 2 s .c o m*/ if (actualIntervalTmp.getStart().isBefore(dataInterval.getStart())) { actualIntervalTmp = actualIntervalTmp.withStart(dataInterval.getStart()); } if (actualIntervalTmp.getEnd().isAfter(dataInterval.getEnd())) { actualIntervalTmp = actualIntervalTmp.withEnd(dataInterval.getEnd()); } final Interval actualInterval = actualIntervalTmp; return new Iterable<Cursor>() { @Override public Iterator<Cursor> iterator() { return FunctionalIterator.create( gran.iterable(actualInterval.getStartMillis(), actualInterval.getEndMillis()).iterator()) .transform(new Function<Long, Cursor>() { EntryHolder currEntry = new EntryHolder(); private final ValueMatcher filterMatcher; { filterMatcher = makeFilterMatcher(filter, currEntry); } @Override public Cursor apply(@Nullable final Long input) { final long timeStart = Math.max(input, actualInterval.getStartMillis()); return new Cursor() { private Iterator<Map.Entry<IncrementalIndex.TimeAndDims, Aggregator[]>> baseIter; private ConcurrentNavigableMap<IncrementalIndex.TimeAndDims, Aggregator[]> cursorMap; final DateTime time; int numAdvanced = -1; boolean done; { cursorMap = index.getSubMap( new IncrementalIndex.TimeAndDims(timeStart, new String[][] {}), new IncrementalIndex.TimeAndDims(Math .min(actualInterval.getEndMillis(), gran.next(timeStart)), new String[][] {})); time = gran.toDateTime(input); reset(); } @Override public DateTime getTime() { return time; } @Override public void advance() { if (!baseIter.hasNext()) { done = true; return; } while (baseIter.hasNext()) { currEntry.set(baseIter.next()); if (filterMatcher.matches()) { return; } } if (!filterMatcher.matches()) { done = true; } } @Override public boolean isDone() { return done; } @Override public void reset() { baseIter = cursorMap.entrySet().iterator(); if (numAdvanced == -1) { numAdvanced = 0; while (baseIter.hasNext()) { currEntry.set(baseIter.next()); if (filterMatcher.matches()) { return; } numAdvanced++; } } else { Iterators.skip(baseIter, numAdvanced); if (baseIter.hasNext()) { currEntry.set(baseIter.next()); } } done = cursorMap.size() == 0 || !baseIter.hasNext(); } @Override public DimensionSelector makeDimensionSelector(String dimension) { final String dimensionName = dimension.toLowerCase(); final IncrementalIndex.DimDim dimValLookup = index .getDimension(dimensionName); if (dimValLookup == null) { return null; } final int maxId = dimValLookup.size(); final int dimIndex = index.getDimensionIndex(dimensionName); return new DimensionSelector() { @Override public IndexedInts getRow() { final ArrayList<Integer> vals = Lists.newArrayList(); if (dimIndex < currEntry.getKey().getDims().length) { final String[] dimVals = currEntry.getKey().getDims()[dimIndex]; if (dimVals != null) { for (String dimVal : dimVals) { int id = dimValLookup.getId(dimVal); if (id < maxId) { vals.add(id); } } } } return new IndexedInts() { @Override public int size() { return vals.size(); } @Override public int get(int index) { return vals.get(index); } @Override public Iterator<Integer> iterator() { return vals.iterator(); } }; } @Override public int getValueCardinality() { return dimValLookup.size(); } @Override public String lookupName(int id) { return dimValLookup.getValue(id); } @Override public int lookupId(String name) { return dimValLookup.getId(name); } }; } @Override public FloatMetricSelector makeFloatMetricSelector(String metric) { final String metricName = metric.toLowerCase(); final Integer metricIndexInt = index.getMetricIndex(metricName); if (metricIndexInt == null) { return new FloatMetricSelector() { @Override public float get() { return 0.0f; } }; } final int metricIndex = metricIndexInt; return new FloatMetricSelector() { @Override public float get() { return currEntry.getValue()[metricIndex].getFloat(); } }; } @Override public ComplexMetricSelector makeComplexMetricSelector(String metric) { final String metricName = metric.toLowerCase(); final Integer metricIndexInt = index.getMetricIndex(metricName); if (metricIndexInt == null) { return null; } final int metricIndex = metricIndexInt; final ComplexMetricSerde serde = ComplexMetrics .getSerdeForType(index.getMetricType(metricName)); return new ComplexMetricSelector() { @Override public Class classOfObject() { return serde.getObjectStrategy().getClazz(); } @Override public Object get() { return currEntry.getValue()[metricIndex].get(); } }; } }; } }); } }; }
From source file:com.metamx.druid.index.v1.IndexStorageAdapter.java
License:Open Source License
@Override public Iterable<Cursor> makeCursors(final Filter filter, final Interval interval, final QueryGranularity gran) { Interval actualIntervalTmp = interval; if (!actualIntervalTmp.overlaps(index.dataInterval)) { return ImmutableList.of(); }//w ww.j a v a 2 s .com if (actualIntervalTmp.getStart().isBefore(index.dataInterval.getStart())) { actualIntervalTmp = actualIntervalTmp.withStart(index.dataInterval.getStart()); } if (actualIntervalTmp.getEnd().isAfter(index.dataInterval.getEnd())) { actualIntervalTmp = actualIntervalTmp.withEnd(index.dataInterval.getEnd()); } final Interval actualInterval = actualIntervalTmp; final Pair<Integer, Integer> intervalStartAndEnd = computeTimeStartEnd(actualInterval); return new Iterable<Cursor>() { @Override public Iterator<Cursor> iterator() { final Offset baseOffset; if (filter == null) { baseOffset = new ArrayBasedOffset(ids, intervalStartAndEnd.lhs); } else { baseOffset = new StartLimitedOffset( new ConciseOffset(filter.goConcise(new IndexBasedBitmapIndexSelector(index))), intervalStartAndEnd.lhs); } final Map<String, Object> metricHolderCache = Maps.newHashMap(); // This after call is not perfect, if there is an exception during processing, it will never get called, // but it's better than nothing and doing this properly all the time requires a lot more fixerating return MoreIterators.after(FunctionalIterator.create( gran.iterable(actualInterval.getStartMillis(), actualInterval.getEndMillis()).iterator()) .keep(new Function<Long, Cursor>() { @Override public Cursor apply(final Long intervalStart) { final Offset offset = new TimestampCheckingOffset(baseOffset, index.timeOffsets, Math.min(actualInterval.getEndMillis(), gran.next(intervalStart))); return new Cursor() { private final Offset initOffset = offset.clone(); private Offset cursorOffset = offset; private final DateTime timestamp = gran.toDateTime(intervalStart); @Override public DateTime getTime() { return timestamp; } @Override public void advance() { cursorOffset.increment(); } @Override public boolean isDone() { return !cursorOffset.withinBounds(); } @Override public void reset() { cursorOffset = initOffset.clone(); } @Override public DimensionSelector makeDimensionSelector(String dimension) { final String dimensionName = dimension.toLowerCase(); final String[] nameLookup = index.reverseDimLookup.get(dimensionName); if (nameLookup == null) { return null; } return new DimensionSelector() { final Map<String, Integer> dimValLookup = index.dimIdLookup .get(dimensionName); final DimensionColumn dimColumn = index.dimensionValues .get(dimensionName); final int[][] dimensionExpansions = dimColumn.getDimensionExpansions(); final int[] dimensionRowValues = dimColumn.getDimensionRowValues(); @Override public IndexedInts getRow() { return new ArrayBasedIndexedInts( dimensionExpansions[dimensionRowValues[cursorOffset .getOffset()]]); } @Override public int getValueCardinality() { return nameLookup.length; } @Override public String lookupName(int id) { return nameLookup[id]; } @Override public int lookupId(String name) { final Integer retVal = dimValLookup.get(name); return retVal == null ? -1 : retVal; } }; } @Override public FloatMetricSelector makeFloatMetricSelector(String metric) { String metricName = metric.toLowerCase(); IndexedFloats cachedFloats = (IndexedFloats) metricHolderCache.get(metric); if (cachedFloats == null) { MetricHolder holder = index.metricVals.get(metricName); if (holder == null) { return new FloatMetricSelector() { @Override public float get() { return 0.0f; } }; } cachedFloats = holder.getFloatType(); metricHolderCache.put(metricName, cachedFloats); } final IndexedFloats metricVals = cachedFloats; return new FloatMetricSelector() { @Override public float get() { return metricVals.get(cursorOffset.getOffset()); } }; } @Override public ComplexMetricSelector makeComplexMetricSelector(String metric) { final String metricName = metric.toLowerCase(); Indexed cachedComplex = (Indexed) metricHolderCache.get(metricName); if (cachedComplex == null) { MetricHolder holder = index.metricVals.get(metricName); if (holder != null) { cachedComplex = holder.getComplexType(); metricHolderCache.put(metricName, cachedComplex); } } if (cachedComplex == null) { return null; } final Indexed vals = cachedComplex; return new ComplexMetricSelector() { @Override public Class classOfObject() { return vals.getClazz(); } @Override public Object get() { return vals.get(cursorOffset.getOffset()); } }; } }; } }), new Runnable() { @Override public void run() { for (Object object : metricHolderCache.values()) { if (object instanceof Closeable) { Closeables.closeQuietly((Closeable) object); } } } }); } }; }
From source file:com.metamx.druid.index.v1.MMappedIndexStorageAdapter.java
License:Open Source License
@Override public Iterable<Cursor> makeCursors(Filter filter, Interval interval, QueryGranularity gran) { Interval actualInterval = interval; if (!actualInterval.overlaps(index.dataInterval)) { return ImmutableList.of(); }/*from w w w . ja v a 2 s. c o m*/ if (actualInterval.getStart().isBefore(index.dataInterval.getStart())) { actualInterval = actualInterval.withStart(index.dataInterval.getStart()); } if (actualInterval.getEnd().isAfter(index.dataInterval.getEnd())) { actualInterval = actualInterval.withEnd(index.dataInterval.getEnd()); } final Iterable<Cursor> iterable; if (filter == null) { iterable = new NoFilterCursorIterable(index, actualInterval, gran); } else { Offset offset = new ConciseOffset(filter.goConcise(new MMappedBitmapIndexSelector(index))); iterable = new CursorIterable(index, actualInterval, gran, offset); } return FunctionalIterable.create(iterable).keep(Functions.<Cursor>identity()); }
From source file:com.metamx.druid.index.v1.QueryableIndexStorageAdapter.java
License:Open Source License
@Override public Iterable<Cursor> makeCursors(Filter filter, Interval interval, QueryGranularity gran) { Interval actualInterval = interval; final Interval dataInterval = getInterval(); if (!actualInterval.overlaps(dataInterval)) { return ImmutableList.of(); }/* www .ja v a 2 s . co m*/ if (actualInterval.getStart().isBefore(dataInterval.getStart())) { actualInterval = actualInterval.withStart(dataInterval.getStart()); } if (actualInterval.getEnd().isAfter(dataInterval.getEnd())) { actualInterval = actualInterval.withEnd(dataInterval.getEnd()); } final Iterable<Cursor> iterable; if (filter == null) { iterable = new NoFilterCursorIterable(index, actualInterval, gran); } else { Offset offset = new ConciseOffset(filter.goConcise(new MMappedBitmapIndexSelector(index))); iterable = new CursorIterable(index, actualInterval, gran, offset); } return FunctionalIterable.create(iterable).keep(Functions.<Cursor>identity()); }
From source file:com.stagecents.pay.domain.PayCycle.java
License:Open Source License
/** * Returns the number of elapsed days in this pay cycle including the given * time interval./*w ww. j a v a 2 s.c om*/ * * @param arg The given time interval * @return The number of days since the beginning of this pay cycle, * inclusive of the given time interval. */ private int getCycleDays(Interval arg) { return Days.daysIn(arg.withStart(getWeeklyCycleStart(arg))).getDays(); }
From source file:cz.cesnet.shongo.controller.api.rpc.ReservationServiceImpl.java
@Override public Object checkAvailability(AvailabilityCheckRequest request) { checkNotNull("request", request); SecurityToken securityToken = request.getSecurityToken(); authorization.validate(securityToken); EntityManager entityManager = entityManagerFactory.createEntityManager(); ReservationRequestManager reservationRequestManager = new ReservationRequestManager(entityManager); try {/*from w w w.j a v a 2 s .co m*/ // We must check only the future (because scheduler allocates only in future) DateTime minimumDateTime = DateTime.now(); Interval slot = request.getSlot(); if (slot.getEnd().isBefore(minimumDateTime)) { throw new ControllerReportSet.ReservationRequestEmptyDurationException(); } if (slot.getStart().isBefore(minimumDateTime)) { slot = slot.withStart(minimumDateTime); } Specification specificationApi = request.getSpecification(); cz.cesnet.shongo.controller.booking.specification.Specification specification = null; Interval allocationSlot = slot; if (specificationApi != null) { specification = cz.cesnet.shongo.controller.booking.specification.Specification .createFromApi(specificationApi, entityManager); if (specification instanceof SpecificationIntervalUpdater) { SpecificationIntervalUpdater intervalUpdater = (SpecificationIntervalUpdater) specification; allocationSlot = intervalUpdater.updateInterval(allocationSlot, minimumDateTime); } } // Create scheduler context SchedulerContext schedulerContext = new SchedulerContext(DateTime.now(), cache, entityManager, new AuthorizationManager(entityManager, authorization)); schedulerContext.setPurpose(request.getPurpose()); // Ignore reservations for already allocated reservation request SchedulerContextState schedulerContextState = schedulerContext.getState(); String ignoredReservationRequestId = request.getIgnoredReservationRequestId(); if (ignoredReservationRequestId != null) { ObjectIdentifier objectId = ObjectIdentifier.parse(ignoredReservationRequestId, ObjectType.RESERVATION_REQUEST); cz.cesnet.shongo.controller.booking.request.AbstractReservationRequest ignoredReservationRequest = reservationRequestManager .get(objectId.getPersistenceId()); for (cz.cesnet.shongo.controller.booking.reservation.Reservation reservation : ignoredReservationRequest .getAllocation().getReservations()) { if (allocationSlot.overlaps(reservation.getSlot())) { schedulerContextState.addAvailableReservation(reservation, AvailableReservation.Type.REALLOCATABLE); } } for (cz.cesnet.shongo.controller.booking.request.ReservationRequest childReservationRequest : ignoredReservationRequest .getAllocation().getChildReservationRequests()) { for (cz.cesnet.shongo.controller.booking.reservation.Reservation reservation : childReservationRequest .getAllocation().getReservations()) { if (reservation.getSlot().overlaps(slot)) { schedulerContextState.addAvailableReservation(reservation, AvailableReservation.Type.REALLOCATABLE); } } } } try { // Check reservation request reusability String reservationRequestId = request.getReservationRequestId(); if (reservationRequestId != null) { ObjectIdentifier objectId = ObjectIdentifier.parse(reservationRequestId, ObjectType.RESERVATION_REQUEST); cz.cesnet.shongo.controller.booking.request.AbstractReservationRequest reservationRequest = reservationRequestManager .get(objectId.getPersistenceId()); schedulerContext.setReusableAllocation(reservationRequest.getAllocation(), slot); } // Check specification availability if (specification != null) { if (specification instanceof ReservationTaskProvider) { try { entityManager.getTransaction().begin(); ReservationTaskProvider reservationTaskProvider = (ReservationTaskProvider) specification; ReservationTask reservationTask = reservationTaskProvider .createReservationTask(schedulerContext, slot); reservationTask.perform(); } finally { entityManager.getTransaction().rollback(); } } else { throw new SchedulerReportSet.SpecificationNotAllocatableException(specification); } } } catch (SchedulerException exception) { // Specification cannot be allocated or reservation request cannot be reused in requested time slot return exception.getReport().toAllocationStateReport( authorization.isAdministrator(securityToken) ? Report.UserType.DOMAIN_ADMIN : Report.UserType.USER); } // Request is available return Boolean.TRUE; } finally { entityManager.close(); } }
From source file:io.druid.segment.incremental.IncrementalIndexStorageAdapter.java
License:Apache License
@Override public Sequence<Cursor> makeCursors(final Filter filter, final Interval interval, final QueryGranularity gran) { if (index.isEmpty()) { return Sequences.empty(); }/* w ww. j a v a2s . com*/ Interval actualIntervalTmp = interval; final Interval dataInterval = new Interval(getMinTime().getMillis(), gran.next(gran.truncate(getMaxTime().getMillis()))); if (!actualIntervalTmp.overlaps(dataInterval)) { return Sequences.empty(); } if (actualIntervalTmp.getStart().isBefore(dataInterval.getStart())) { actualIntervalTmp = actualIntervalTmp.withStart(dataInterval.getStart()); } if (actualIntervalTmp.getEnd().isAfter(dataInterval.getEnd())) { actualIntervalTmp = actualIntervalTmp.withEnd(dataInterval.getEnd()); } final Interval actualInterval = actualIntervalTmp; return Sequences.map( Sequences.simple(gran.iterable(actualInterval.getStartMillis(), actualInterval.getEndMillis())), new Function<Long, Cursor>() { EntryHolder currEntry = new EntryHolder(); private final ValueMatcher filterMatcher; { filterMatcher = makeFilterMatcher(filter, currEntry); } @Override public Cursor apply(@Nullable final Long input) { final long timeStart = Math.max(input, actualInterval.getStartMillis()); return new Cursor() { private Iterator<Map.Entry<IncrementalIndex.TimeAndDims, Integer>> baseIter; private ConcurrentNavigableMap<IncrementalIndex.TimeAndDims, Integer> cursorMap; final DateTime time; int numAdvanced = -1; boolean done; { cursorMap = index.getSubMap( new IncrementalIndex.TimeAndDims(timeStart, new String[][] {}), new IncrementalIndex.TimeAndDims( Math.min(actualInterval.getEndMillis(), gran.next(input)), new String[][] {})); time = gran.toDateTime(input); reset(); } @Override public DateTime getTime() { return time; } @Override public void advance() { if (!baseIter.hasNext()) { done = true; return; } while (baseIter.hasNext()) { if (Thread.interrupted()) { throw new QueryInterruptedException(); } currEntry.set(baseIter.next()); if (filterMatcher.matches()) { return; } } if (!filterMatcher.matches()) { done = true; } } @Override public void advanceTo(int offset) { int count = 0; while (count < offset && !isDone()) { advance(); count++; } } @Override public boolean isDone() { return done; } @Override public void reset() { baseIter = cursorMap.entrySet().iterator(); if (numAdvanced == -1) { numAdvanced = 0; } else { Iterators.advance(baseIter, numAdvanced); } if (Thread.interrupted()) { throw new QueryInterruptedException(); } boolean foundMatched = false; while (baseIter.hasNext()) { currEntry.set(baseIter.next()); if (filterMatcher.matches()) { foundMatched = true; break; } numAdvanced++; } done = !foundMatched && (cursorMap.size() == 0 || !baseIter.hasNext()); } @Override public DimensionSelector makeDimensionSelector(final String dimension, @Nullable final ExtractionFn extractionFn) { if (dimension.equals(Column.TIME_COLUMN_NAME)) { return new SingleScanTimeDimSelector(makeLongColumnSelector(dimension), extractionFn); } final IncrementalIndex.DimDim dimValLookup = index.getDimension(dimension); if (dimValLookup == null) { return NULL_DIMENSION_SELECTOR; } final int maxId = dimValLookup.size(); final int dimIndex = index.getDimensionIndex(dimension); return new DimensionSelector() { @Override public IndexedInts getRow() { final ArrayList<Integer> vals = Lists.newArrayList(); if (dimIndex < currEntry.getKey().getDims().length) { final String[] dimVals = currEntry.getKey().getDims()[dimIndex]; if (dimVals != null) { for (String dimVal : dimVals) { int id = dimValLookup.getId(dimVal); if (id < maxId) { vals.add(id); } } } } // check for null entry if (vals.isEmpty() && dimValLookup.contains(null)) { int id = dimValLookup.getId(null); if (id < maxId) { vals.add(id); } } return new IndexedInts() { @Override public int size() { return vals.size(); } @Override public int get(int index) { return vals.get(index); } @Override public Iterator<Integer> iterator() { return vals.iterator(); } @Override public void fill(int index, int[] toFill) { throw new UnsupportedOperationException("fill not supported"); } @Override public void close() throws IOException { } }; } @Override public int getValueCardinality() { return maxId; } @Override public String lookupName(int id) { final String value = dimValLookup.getValue(id); return extractionFn == null ? value : extractionFn.apply(value); } @Override public int lookupId(String name) { if (extractionFn != null) { throw new UnsupportedOperationException( "cannot perform lookup when applying an extraction function"); } return dimValLookup.getId(name); } }; } @Override public FloatColumnSelector makeFloatColumnSelector(String columnName) { final Integer metricIndexInt = index.getMetricIndex(columnName); if (metricIndexInt == null) { return new FloatColumnSelector() { @Override public float get() { return 0.0f; } }; } final int metricIndex = metricIndexInt; return new FloatColumnSelector() { @Override public float get() { return index.getMetricFloatValue(currEntry.getValue(), metricIndex); } }; } @Override public LongColumnSelector makeLongColumnSelector(String columnName) { if (columnName.equals(Column.TIME_COLUMN_NAME)) { return new LongColumnSelector() { @Override public long get() { return currEntry.getKey().getTimestamp(); } }; } final Integer metricIndexInt = index.getMetricIndex(columnName); if (metricIndexInt == null) { return new LongColumnSelector() { @Override public long get() { return 0L; } }; } final int metricIndex = metricIndexInt; return new LongColumnSelector() { @Override public long get() { return index.getMetricLongValue(currEntry.getValue(), metricIndex); } }; } @Override public ObjectColumnSelector makeObjectColumnSelector(String column) { if (column.equals(Column.TIME_COLUMN_NAME)) { return new ObjectColumnSelector<Long>() { @Override public Class classOfObject() { return Long.TYPE; } @Override public Long get() { return currEntry.getKey().getTimestamp(); } }; } final Integer metricIndexInt = index.getMetricIndex(column); if (metricIndexInt != null) { final int metricIndex = metricIndexInt; final ComplexMetricSerde serde = ComplexMetrics .getSerdeForType(index.getMetricType(column)); return new ObjectColumnSelector() { @Override public Class classOfObject() { return serde.getObjectStrategy().getClazz(); } @Override public Object get() { return index.getMetricObjectValue(currEntry.getValue(), metricIndex); } }; } final Integer dimensionIndexInt = index.getDimensionIndex(column); if (dimensionIndexInt != null) { final int dimensionIndex = dimensionIndexInt; return new ObjectColumnSelector<Object>() { @Override public Class classOfObject() { return Object.class; } @Override public Object get() { IncrementalIndex.TimeAndDims key = currEntry.getKey(); if (key == null) { return null; } String[][] dims = key.getDims(); if (dimensionIndex >= dims.length) { return null; } final String[] dimVals = dims[dimensionIndex]; if (dimVals == null || dimVals.length == 0) { return null; } if (dimVals.length == 1) { return dimVals[0]; } return dimVals; } }; } return null; } }; } }); }
From source file:io.druid.segment.QueryableIndexStorageAdapter.java
License:Apache License
@Override public Sequence<Cursor> makeCursors(Filter filter, Interval interval, QueryGranularity gran) { Interval actualInterval = interval; long minDataTimestamp = getMinTime().getMillis(); long maxDataTimestamp = getMaxTime().getMillis(); final Interval dataInterval = new Interval(minDataTimestamp, gran.next(gran.truncate(maxDataTimestamp))); if (!actualInterval.overlaps(dataInterval)) { return Sequences.empty(); }/*from ww w . j a v a2 s. c o m*/ if (actualInterval.getStart().isBefore(dataInterval.getStart())) { actualInterval = actualInterval.withStart(dataInterval.getStart()); } if (actualInterval.getEnd().isAfter(dataInterval.getEnd())) { actualInterval = actualInterval.withEnd(dataInterval.getEnd()); } final Offset offset; if (filter == null) { offset = new NoFilterOffset(0, index.getNumRows()); } else { final ColumnSelectorBitmapIndexSelector selector = new ColumnSelectorBitmapIndexSelector( index.getBitmapFactoryForDimensions(), index); offset = new BitmapOffset(selector.getBitmapFactory(), filter.getBitmapIndex(selector)); } return Sequences.filter( new CursorSequenceBuilder(index, actualInterval, gran, offset, maxDataTimestamp).build(), Predicates.<Cursor>notNull()); }