Example usage for org.joda.time Interval getStart

List of usage examples for org.joda.time Interval getStart

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. Interval
  6. getStart

Introduction

In this page you can find the example usage for org.joda.time Interval getStart.

Prototype

public DateTime getStart()

Source Link

Document

Gets the start of this time interval, which is inclusive, as a DateTime.

Usage

From source file:org.apache.druid.server.audit.SQLAuditManager.java

License:Apache License

@Override
public List<AuditEntry> fetchAuditHistory(final String type, Interval interval) {
    final Interval theInterval = getIntervalOrDefault(interval);
    return dbi.withHandle(new HandleCallback<List<AuditEntry>>() {
        @Override//  w ww  .j a  va 2 s. co  m
        public List<AuditEntry> withHandle(Handle handle) {
            return handle.createQuery(StringUtils.format(
                    "SELECT payload FROM %s WHERE type = :type and created_date between :start_date and :end_date ORDER BY created_date",
                    getAuditTable())).bind("type", type).bind("start_date", theInterval.getStart().toString())
                    .bind("end_date", theInterval.getEnd().toString()).map(new ResultSetMapper<AuditEntry>() {
                        @Override
                        public AuditEntry map(int index, ResultSet r, StatementContext ctx)
                                throws SQLException {
                            try {
                                return jsonMapper.readValue(r.getBytes("payload"), AuditEntry.class);
                            } catch (IOException e) {
                                throw new SQLException(e);
                            }
                        }
                    }).list();
        }
    });
}

From source file:org.apache.druid.server.coordinator.helper.NewestSegmentFirstIterator.java

License:Apache License

/**
 * Returns the initial searchInterval which is {@code (timeline.first().start, timeline.last().end - skipOffset)}.
 *
 * @param timeline      timeline of a dataSource
 * @param skipIntervals intervals to skip
 *
 * @return found interval to search or null if it's not found
 *///from  w  ww. ja v  a 2  s  . c o  m
private static List<Interval> findInitialSearchInterval(VersionedIntervalTimeline<String, DataSegment> timeline,
        Period skipOffset, @Nullable List<Interval> skipIntervals) {
    Preconditions.checkArgument(timeline != null && !timeline.isEmpty(),
            "timeline should not be null or empty");
    Preconditions.checkNotNull(skipOffset, "skipOffset");

    final TimelineObjectHolder<String, DataSegment> first = Preconditions.checkNotNull(timeline.first(),
            "first");
    final TimelineObjectHolder<String, DataSegment> last = Preconditions.checkNotNull(timeline.last(), "last");
    final List<Interval> fullSkipIntervals = sortAndAddSkipIntervalFromLatest(last.getInterval().getEnd(),
            skipOffset, skipIntervals);

    final Interval totalInterval = new Interval(first.getInterval().getStart(), last.getInterval().getEnd());
    final List<Interval> filteredInterval = filterSkipIntervals(totalInterval, fullSkipIntervals);
    final List<Interval> searchIntervals = new ArrayList<>();

    for (Interval lookupInterval : filteredInterval) {
        final List<TimelineObjectHolder<String, DataSegment>> holders = timeline
                .lookup(new Interval(lookupInterval.getStart(), lookupInterval.getEnd()));

        final List<DataSegment> segments = holders.stream()
                .flatMap(holder -> StreamSupport.stream(holder.getObject().spliterator(), false))
                .map(PartitionChunk::getObject)
                .filter(segment -> lookupInterval.contains(segment.getInterval()))
                .sorted((s1, s2) -> Comparators.intervalsByStartThenEnd().compare(s1.getInterval(),
                        s2.getInterval()))
                .collect(Collectors.toList());

        if (!segments.isEmpty()) {
            searchIntervals.add(new Interval(segments.get(0).getInterval().getStart(),
                    segments.get(segments.size() - 1).getInterval().getEnd()));
        }
    }

    return searchIntervals;
}

From source file:org.apache.druid.server.coordinator.helper.NewestSegmentFirstIterator.java

License:Apache License

/**
 * Returns a list of intervals which are contained by totalInterval but don't ovarlap with skipIntervals.
 *
 * @param totalInterval total interval//from   w w w  . j  a  v  a  2  s.  c  o m
 * @param skipIntervals intervals to skip. This should be sorted by {@link Comparators#intervalsByStartThenEnd()}.
 */
@VisibleForTesting
static List<Interval> filterSkipIntervals(Interval totalInterval, List<Interval> skipIntervals) {
    final List<Interval> filteredIntervals = new ArrayList<>(skipIntervals.size() + 1);

    DateTime remainingStart = totalInterval.getStart();
    DateTime remainingEnd = totalInterval.getEnd();
    for (Interval skipInterval : skipIntervals) {
        if (skipInterval.getStart().isBefore(remainingStart) && skipInterval.getEnd().isAfter(remainingStart)) {
            remainingStart = skipInterval.getEnd();
        } else if (skipInterval.getStart().isBefore(remainingEnd)
                && skipInterval.getEnd().isAfter(remainingEnd)) {
            remainingEnd = skipInterval.getStart();
        } else if (!remainingStart.isAfter(skipInterval.getStart())
                && !remainingEnd.isBefore(skipInterval.getEnd())) {
            filteredIntervals.add(new Interval(remainingStart, skipInterval.getStart()));
            remainingStart = skipInterval.getEnd();
        } else {
            // Ignore this skipInterval
            log.warn("skipInterval[%s] is not contained in remainingInterval[%s]", skipInterval,
                    new Interval(remainingStart, remainingEnd));
        }
    }

    if (!remainingStart.equals(remainingEnd)) {
        filteredIntervals.add(new Interval(remainingStart, remainingEnd));
    }

    return filteredIntervals;
}

From source file:org.apache.druid.timeline.VersionedIntervalTimeline.java

License:Apache License

public boolean isOvershadowed(Interval interval, VersionType version, ObjectType object) {
    lock.readLock().lock();//  w w  w  . j  a v a  2s .  c o m
    try {
        TimelineEntry entry = completePartitionsTimeline.get(interval);
        if (entry != null) {
            final int majorVersionCompare = versionComparator.compare(version, entry.getVersion());
            if (majorVersionCompare == 0) {
                for (PartitionChunk<ObjectType> chunk : entry.partitionHolder) {
                    if (chunk.getObject().overshadows(object)) {
                        return true;
                    }
                }
                return false;
            } else {
                return majorVersionCompare < 0;
            }
        }

        Interval lower = completePartitionsTimeline.floorKey(new Interval(interval.getStart(), DateTimes.MAX));

        if (lower == null || !lower.overlaps(interval)) {
            return false;
        }

        Interval prev = null;
        Interval curr = lower;

        do {
            if (curr == null || //no further keys
                    (prev != null && curr.getStartMillis() > prev.getEndMillis()) //a discontinuity
            ) {
                return false;
            }

            final TimelineEntry timelineEntry = completePartitionsTimeline.get(curr);
            final int versionCompare = versionComparator.compare(version, timelineEntry.getVersion());

            //lower or same version
            if (versionCompare > 0) {
                return false;
            } else if (versionCompare == 0) {
                if (timelineEntry.partitionHolder.stream()
                        .noneMatch(chunk -> chunk.getObject().overshadows(object))) {
                    return false;
                }
            }

            prev = curr;
            curr = completePartitionsTimeline.higherKey(curr);

        } while (interval.getEndMillis() > prev.getEndMillis());

        return true;
    } finally {
        lock.readLock().unlock();
    }
}

From source file:org.apache.druid.timeline.VersionedIntervalTimeline.java

License:Apache License

/**
 * @param timeline/*w  w  w  .j a va2  s  .c o m*/
 * @param key
 * @param entry
 *
 * @return boolean flag indicating whether or not we inserted or discarded something
 */
private boolean addAtKey(NavigableMap<Interval, TimelineEntry> timeline, Interval key, TimelineEntry entry) {
    boolean retVal = false;
    Interval currKey = key;
    Interval entryInterval = entry.getTrueInterval();

    if (!currKey.overlaps(entryInterval)) {
        return false;
    }

    while (entryInterval != null && currKey != null && currKey.overlaps(entryInterval)) {
        final Interval nextKey = timeline.higherKey(currKey);

        final int versionCompare = versionComparator.compare(entry.getVersion(),
                timeline.get(currKey).getVersion());

        if (versionCompare < 0) {
            // since the entry version is lower than the existing one, the existing one overwrites the given entry
            // if overlapped.
            if (currKey.contains(entryInterval)) {
                // the version of the entry of currKey is larger than that of the given entry. Discard it
                return true;
            } else if (currKey.getStart().isBefore(entryInterval.getStart())) {
                //       | entry |
                //     | cur |
                // =>        |new|
                entryInterval = new Interval(currKey.getEnd(), entryInterval.getEnd());
            } else {
                //     | entry |
                //         | cur |
                // =>  |new|
                addIntervalToTimeline(new Interval(entryInterval.getStart(), currKey.getStart()), entry,
                        timeline);

                //     |   entry   |
                //       | cur |
                // =>          |new|
                if (entryInterval.getEnd().isAfter(currKey.getEnd())) {
                    entryInterval = new Interval(currKey.getEnd(), entryInterval.getEnd());
                } else {
                    // Discard this entry since there is no portion of the entry interval that goes past the end of the curr
                    // key interval.
                    entryInterval = null;
                }
            }
        } else if (versionCompare > 0) {
            // since the entry version is greater than the existing one, the given entry overwrites the existing one
            // if overlapped.
            final TimelineEntry oldEntry = timeline.remove(currKey);

            if (currKey.contains(entryInterval)) {
                //     |      cur      |
                //         | entry |
                // =>  |old|  new  |old|
                addIntervalToTimeline(new Interval(currKey.getStart(), entryInterval.getStart()), oldEntry,
                        timeline);
                addIntervalToTimeline(new Interval(entryInterval.getEnd(), currKey.getEnd()), oldEntry,
                        timeline);
                addIntervalToTimeline(entryInterval, entry, timeline);

                return true;
            } else if (currKey.getStart().isBefore(entryInterval.getStart())) {
                //     |   cur  |
                //         |   entry   |
                // =>  |old|
                addIntervalToTimeline(new Interval(currKey.getStart(), entryInterval.getStart()), oldEntry,
                        timeline);
            } else if (entryInterval.getEnd().isBefore(currKey.getEnd())) {
                //            |   cur  |
                //     |   entry   |
                // =>              |old|
                addIntervalToTimeline(new Interval(entryInterval.getEnd(), currKey.getEnd()), oldEntry,
                        timeline);
            }
        } else {
            if (timeline.get(currKey).equals(entry)) {
                // This occurs when restoring segments
                timeline.remove(currKey);
            } else {
                throw new UOE("Cannot add overlapping segments [%s and %s] with the same version [%s]", currKey,
                        entryInterval, entry.getVersion());
            }
        }

        currKey = nextKey;
        retVal = true;
    }

    addIntervalToTimeline(entryInterval, entry, timeline);

    return retVal;
}

From source file:org.apache.druid.timeline.VersionedIntervalTimeline.java

License:Apache License

private List<TimelineObjectHolder<VersionType, ObjectType>> lookup(Interval interval, boolean incompleteOk) {
    List<TimelineObjectHolder<VersionType, ObjectType>> retVal = new ArrayList<>();
    NavigableMap<Interval, TimelineEntry> timeline = (incompleteOk) ? incompletePartitionsTimeline
            : completePartitionsTimeline;

    for (Entry<Interval, TimelineEntry> entry : timeline.entrySet()) {
        Interval timelineInterval = entry.getKey();
        TimelineEntry val = entry.getValue();

        if (timelineInterval.overlaps(interval)) {
            retVal.add(new TimelineObjectHolder<>(timelineInterval, val.getTrueInterval(), val.getVersion(),
                    new PartitionHolder<>(val.getPartitionHolder())));
        }// w  w w.  j  a v a 2s . c  o m
    }

    if (retVal.isEmpty()) {
        return retVal;
    }

    TimelineObjectHolder<VersionType, ObjectType> firstEntry = retVal.get(0);
    if (interval.overlaps(firstEntry.getInterval())
            && interval.getStart().isAfter(firstEntry.getInterval().getStart())) {
        retVal.set(0,
                new TimelineObjectHolder<>(new Interval(interval.getStart(), firstEntry.getInterval().getEnd()),
                        firstEntry.getTrueInterval(), firstEntry.getVersion(), firstEntry.getObject()));
    }

    TimelineObjectHolder<VersionType, ObjectType> lastEntry = retVal.get(retVal.size() - 1);
    if (interval.overlaps(lastEntry.getInterval())
            && interval.getEnd().isBefore(lastEntry.getInterval().getEnd())) {
        retVal.set(retVal.size() - 1,
                new TimelineObjectHolder<>(new Interval(lastEntry.getInterval().getStart(), interval.getEnd()),
                        lastEntry.getTrueInterval(), lastEntry.getVersion(), lastEntry.getObject()));
    }

    return retVal;
}

From source file:org.apache.hadoop.hive.druid.DruidStorageHandlerUtils.java

License:Apache License

private static VersionedIntervalTimeline<String, DataSegment> getTimelineForIntervalWithHandle(
        final Handle handle, final String dataSource, final Interval interval,
        final MetadataStorageTablesConfig dbTables) throws IOException {
    Query<Map<String, Object>> sql = handle.createQuery(String.format(
            "SELECT payload FROM %s WHERE used = true AND dataSource = ? AND start <= ? AND \"end\" >= ?",
            dbTables.getSegmentsTable())).bind(0, dataSource).bind(1, interval.getEnd().toString())
            .bind(2, interval.getStart().toString());

    final VersionedIntervalTimeline<String, DataSegment> timeline = new VersionedIntervalTimeline<>(
            Ordering.natural());// w w  w  . jav  a 2s  .  co  m
    final ResultIterator<byte[]> dbSegments = sql.map(ByteArrayMapper.FIRST).iterator();
    try {
        while (dbSegments.hasNext()) {
            final byte[] payload = dbSegments.next();
            DataSegment segment = JSON_MAPPER.readValue(payload, DataSegment.class);
            timeline.add(segment.getInterval(), segment.getVersion(),
                    segment.getShardSpec().createChunk(segment));
        }
    } finally {
        dbSegments.close();
    }
    return timeline;
}

From source file:org.archfirst.common.datetime.DateTimeUtil.java

License:Apache License

public static final String toString(Interval interval) {
    StringBuilder builder = new StringBuilder();
    DateTimeFormatter fmt = DateTimeFormat.forPattern(DateTimeUtil.DATE_TIME_SEC_PATTERN);

    builder.append("[");
    builder.append(interval.getStart().toString(fmt));
    builder.append(", ");
    builder.append(interval.getEnd().toString(fmt));
    builder.append("]");

    return builder.toString();
}

From source file:org.archfirst.common.datetime.DateTimeUtil.java

License:Apache License

public static Interval intervalEndingOn(Interval interval, DateTime end) {
    return new Interval(interval.getStart(), end);
}

From source file:org.archfirst.common.datetime.IntervalComparator.java

License:Apache License

@Override
public int compare(Interval interval1, Interval interval2) {
    int result = 0; // assume equal

    if (interval1 == null) {
        return -1;
    } else if (interval2 == null) {
        return 1;
    } else {/*from   w  ww .j  av  a 2 s .  c om*/
        result = interval1.getStart().compareTo(interval2.getStart());
        if (result == 0) {
            result = interval1.getEnd().compareTo(interval2.getEnd());
        }
    }

    return result;
}