public static <T> Sequence<T> sort(final Sequence<T> sequence, final Comparator<T> comparator) { List<T> seqList = sequence.toList(); Collections.sort(seqList, comparator); return simple(seqList); }
@Override public Sequence<ScanResultValue> run( final QueryPlus<ScanResultValue> queryPlus, final Map<String, Object> responseContext ) { // Note: this variable is effective only when queryContext has a timeout. // See the comment of CTX_TIMEOUT_AT. final long timeoutAt = System.currentTimeMillis() + QueryContexts.getTimeout(queryPlus.getQuery()); responseContext.put(CTX_TIMEOUT_AT, timeoutAt); return Sequences.concat( Sequences.map( Sequences.simple(queryRunners), new Function<QueryRunner<ScanResultValue>, Sequence<ScanResultValue>>() { @Override public Sequence<ScanResultValue> apply(final QueryRunner<ScanResultValue> input) { return input.run(queryPlus, responseContext); } } ) ); } };
@Override public Sequence<T> run(final QueryPlus<T> queryPlus, final Map<String, Object> responseContext) { return Sequences.concat( Sequences.map( queryRunners, new Function<QueryRunner<T>, Sequence<T>>() { @Override public Sequence<T> apply(final QueryRunner<T> input) { return input.run(queryPlus, responseContext); } } ) ); } }
public TestSequence(final Iterable<T> iterable) { base = Sequences.withBaggage( Sequences.simple(iterable), new Closeable() { @Override public void close() { closed.set(true); } } ); }
configSupplier.get(), bufferPool, Sequences.concat( Sequences.map( Sequences.simple(outerQuery.getIntervals()), new Function<Interval, Sequence<Row>>() return Sequences.withBaggage( outerQuery.postProcess(GroupByQueryHelper.postAggregate(query, outerQueryResultIndex)), outerQueryResultIndex
@Override public Sequence<Cursor> makeCursors( @Nullable final Filter filter, final Interval interval, final VirtualColumns virtualColumns, final Granularity gran, final boolean descending, @Nullable QueryMetrics<?> queryMetrics ) { if (index.isEmpty()) { return Sequences.empty(); } final Interval dataInterval = new Interval(getMinTime(), gran.bucketEnd(getMaxTime())); if (!interval.overlaps(dataInterval)) { return Sequences.empty(); } final Interval actualInterval = interval.overlap(dataInterval); Iterable<Interval> intervals = gran.getIterable(actualInterval); if (descending) { intervals = Lists.reverse(ImmutableList.copyOf(intervals)); } return Sequences .simple(intervals) .map(i -> new IncrementalIndexCursor(virtualColumns, descending, filter, i, actualInterval, gran)); }
return Sequences.withBaggage( Sequences.map( Sequences.simple(iterable), new Function<Interval, Cursor>()
public static Sequence<Row> postAggregate(final GroupByQuery query, IncrementalIndex index) { return Sequences.map( Sequences.simple(index.iterableWithPostAggregations(query.getPostAggregatorSpecs(), query.isDescending())), new Function<Row, Row>() { @Override public Row apply(Row input) { final MapBasedRow row = (MapBasedRow) input; return new MapBasedRow( query.getGranularity() .toDateTime(row.getTimestampFromEpoch()), row.getEvent() ); } } ); }
@Override public Object apply(final OutputStream out) { evaluateSequenceForSideEffects( Sequences.map( executeQuery(injector, index, query), new Function<SegmentAnalysis, Object>() { @Override public Object apply(SegmentAnalysis analysis) { try { objectMapper.writeValue(out, analysis); } catch (IOException e) { throw Throwables.propagate(e); } return null; } } ) ); return null; } }
return Sequences.concat( Sequences.withBaggage( Sequences.map( cursors, new Function<Cursor, Sequence<Row>>()
public static <T> Sequence<T> withBaggage(final Sequence<T> seq, final Closeable baggage) { Preconditions.checkNotNull(baggage, "baggage"); return wrap(seq, new SequenceWrapper() { @Override public void after(boolean isDone, Throwable thrown) throws Exception { baggage.close(); } }); }
@Override public Sequence run(QueryPlus queryPlus, Map responseContext) { return Sequences.withEffect( Sequences.simple(Collections.singletonList(value)), new Runnable() { @Override public void run() { throw new SegmentMissingException("FAILSAUCE"); } }, Execs.directExecutor() ); } },
public static <T> Sequence<T> concat(Sequence<T>... sequences) { return concat(Arrays.asList(sequences)); }
@Override @SuppressWarnings("unchecked") public Sequence<Object[]> runQuery() { // Lazy: run each query in sequence, not all at once. if (limit == 0) { return Sequences.empty(); } else { final Sequence baseSequence = Sequences.concat( FluentIterable.from(rels).transform(rel -> ((DruidRel) rel).runQuery()) ); return limit > 0 ? baseSequence.limit(limit) : baseSequence; } }
default Sequence<T> withBaggage(Closeable baggage) { return Sequences.withBaggage(this, baggage); } }
@Override public Sequence<T> run(QueryPlus<T> queryPlus, Map<String, Object> responseContext) { return Sequences.empty(); } }
final Sequence<T> wrappedSequence = Sequences.map( sequence, input -> { return Sequences.withEffect( wrappedSequence, () -> {