List of usage examples for org.joda.time Interval getEndMillis
public long getEndMillis()
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(); }//w w w. j av a2 s . co 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.IncrementalIndexStorageAdapter.java
License:Open Source License
@Override public Iterable<SearchHit> searchDimensions(final SearchQuery query, final Filter filter) { final List<String> dimensions = query.getDimensions(); final int[] dimensionIndexes; final String[] dimensionNames; final List<String> dimensionOrder = index.getDimensions(); if (dimensions == null || dimensions.isEmpty()) { dimensionIndexes = new int[dimensionOrder.size()]; dimensionNames = new String[dimensionIndexes.length]; Iterator<String> dimensionOrderIter = dimensionOrder.iterator(); for (int i = 0; i < dimensionIndexes.length; ++i) { dimensionNames[i] = dimensionOrderIter.next(); dimensionIndexes[i] = index.getDimensionIndex(dimensionNames[i]); }//from ww w .j a va2 s .co m } else { int[] tmpDimensionIndexes = new int[dimensions.size()]; String[] tmpDimensionNames = new String[dimensions.size()]; int i = 0; for (String dimension : dimensions) { Integer dimIndex = index.getDimensionIndex(dimension.toLowerCase()); if (dimIndex != null) { tmpDimensionNames[i] = dimension; tmpDimensionIndexes[i] = dimIndex; ++i; } } if (i != tmpDimensionIndexes.length) { dimensionIndexes = new int[i]; dimensionNames = new String[i]; System.arraycopy(tmpDimensionIndexes, 0, dimensionIndexes, 0, i); System.arraycopy(tmpDimensionNames, 0, dimensionNames, 0, i); } else { dimensionIndexes = tmpDimensionIndexes; dimensionNames = tmpDimensionNames; } } final List<Interval> queryIntervals = query.getIntervals(); if (queryIntervals.size() != 1) { throw new IAE("Can only handle one interval, got query[%s]", query); } final Interval queryInterval = queryIntervals.get(0); final long intervalStart = queryInterval.getStartMillis(); final long intervalEnd = queryInterval.getEndMillis(); final EntryHolder holder = new EntryHolder(); final ValueMatcher theMatcher = makeFilterMatcher(filter, holder); final SearchQuerySpec searchQuerySpec = query.getQuery(); final TreeSet<SearchHit> retVal = Sets.newTreeSet(query.getSort().getComparator()); ConcurrentNavigableMap<IncrementalIndex.TimeAndDims, Aggregator[]> facts = index.getSubMap( new IncrementalIndex.TimeAndDims(intervalStart, new String[][] {}), new IncrementalIndex.TimeAndDims(intervalEnd, new String[][] {})); for (Map.Entry<IncrementalIndex.TimeAndDims, Aggregator[]> entry : facts.entrySet()) { holder.set(entry); final IncrementalIndex.TimeAndDims key = holder.getKey(); final long timestamp = key.getTimestamp(); if (timestamp >= intervalStart && timestamp < intervalEnd && theMatcher.matches()) { final String[][] dims = key.getDims(); for (int i = 0; i < dimensionIndexes.length; ++i) { if (dimensionIndexes[i] < dims.length) { final String[] dimVals = dims[dimensionIndexes[i]]; if (dimVals != null) { for (int j = 0; j < dimVals.length; ++j) { if (searchQuerySpec.accept(dimVals[j])) { retVal.add(new SearchHit(dimensionNames[i], dimVals[j])); } } } } } } } return new FunctionalIterable<SearchHit>(retVal).limit(query.getLimit()); }
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(); }//from w ww . ja v a 2 s . c o m 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.query.IntervalChunkingQueryRunner.java
License:Open Source License
private Iterable<Interval> splitInterval(Interval interval) { if (interval.getEndMillis() == interval.getStartMillis()) { return Lists.newArrayList(interval); }/*from www . j av a2 s. c o m*/ List<Interval> intervals = Lists.newArrayList(); Iterator<Long> timestamps = new PeriodGranularity(period, null, null) .iterable(interval.getStartMillis(), interval.getEndMillis()).iterator(); long start = Math.max(timestamps.next(), interval.getStartMillis()); while (timestamps.hasNext()) { long end = timestamps.next(); intervals.add(new Interval(start, end)); start = end; } if (start < interval.getEndMillis()) { intervals.add(new Interval(start, interval.getEndMillis())); } return intervals; }
From source file:com.peertopark.java.dates.Intervals.java
License:Apache License
public static Collection<Interval> split(Interval interval, Duration duration) { ArrayList<Interval> intervals = new ArrayList<Interval>(); long startMillis = interval.getStartMillis(); long endMillis = interval.getEndMillis(); long chunks = interval.toDurationMillis() / duration.getMillis(); for (int i = 0; i < chunks; i++) { long temporalEndMillis = startMillis + duration.getMillis(); intervals.add(getInterval(startMillis, temporalEndMillis)); startMillis = temporalEndMillis; }//from w w w . j a va 2s. com if (startMillis < endMillis) { intervals.add(getInterval(startMillis, endMillis)); } return intervals; }
From source file:com.pinterest.deployservice.db.DBBuildDAOImpl.java
License:Apache License
@Override public List<BuildBean> getAcceptedBuilds(String buildName, String branch, Interval interval, int limit) throws Exception { ResultSetHandler<List<BuildBean>> h = new BeanListHandler<>(BuildBean.class); if (StringUtils.isNotEmpty(branch)) { return new QueryRunner(dataSource).query(String.format(GET_ACCEPTED_BUILDS_BETWEEN_TEMPLATE2, buildName, branch, interval.getStartMillis(), interval.getEndMillis(), limit), h); } else {//ww w .j a v a2s . com return new QueryRunner(dataSource).query(String.format(GET_ACCEPTED_BUILDS_BETWEEN_TEMPLATE, buildName, interval.getStartMillis(), interval.getEndMillis(), limit), h); } }
From source file:com.pinterest.deployservice.db.DBDeployDAOImpl.java
License:Apache License
@Override public List<DeployBean> getAcceptedDeploys(String envId, Interval interval, int size) throws Exception { ResultSetHandler<List<DeployBean>> h = new BeanListHandler<>(DeployBean.class); String typesClause = QueryUtils.genEnumGroupClause(StateMachines.AUTO_PROMOTABLE_DEPLOY_TYPE); return new QueryRunner(dataSource).query(String.format(GET_ACCEPTED_DEPLOYS_TEMPLATE, envId, typesClause, interval.getStartMillis(), interval.getEndMillis(), size), h); }
From source file:com.pinterest.deployservice.db.DBDeployDAOImpl.java
License:Apache License
@Override public List<DeployBean> getAcceptedDeploysDelayed(String envId, Interval interval) throws Exception { ResultSetHandler<List<DeployBean>> h = new BeanListHandler<>(DeployBean.class); return new QueryRunner(dataSource).query(String.format(GET_ACCEPTED_DEPLOYS_DELAYED_TEMPLATE, envId, interval.getStartMillis(), interval.getEndMillis()), h); }
From source file:com.yahoo.bard.webservice.util.SimplifiedIntervalList.java
License:Apache License
/** * Given a sorted linked list of intervals, add the following interval to the end, merging the incoming interval * to any tail intervals which overlap or abut with it. * <p>//from w w w.ja v a2s . c o m * In the case where added intervals are at the end of the list, this is efficient. In the case where they are not, * this degrades to an insertion sort. * * @param interval The interval to be merged and added to this list */ private void appendWithMerge(Interval interval) { // Do not store empty intervals if (interval.toDurationMillis() == 0) { return; } if (isEmpty()) { addLast(interval); return; } final Interval previous = peekLast(); // If this interval does not belong at the end, removeLast until it does if (interval.getStart().isBefore(previous.getStart())) { mergeInner(interval); return; } if (previous.gap(interval) != null) { addLast(interval); return; } removeLast(); Interval newEnd = new Interval(Math.min(previous.getStartMillis(), interval.getStartMillis()), Math.max(previous.getEndMillis(), interval.getEndMillis())); addLast(newEnd); }
From source file:de.fraunhofer.iosb.ilt.sta.persistence.postgres.EntityInserter.java
License:Open Source License
private static <T extends StoreClause> T insertTimeInterval(T clause, DateTimePath<Timestamp> startPath, DateTimePath<Timestamp> endPath, TimeInterval time) { if (time == null) { return clause; }/*from w ww . ja v a 2 s .c o m*/ Interval interval = time.getInterval(); clause.set(startPath, new Timestamp(interval.getStartMillis())); clause.set(endPath, new Timestamp(interval.getEndMillis())); return clause; }