@Override public void run() { seq.toList(); } }
@Override public <OutType> OutType accumulate(OutType initValue, final Accumulator<OutType, T> accumulator) { return baseSequences.accumulate(initValue, (accumulated, in) -> in.accumulate(accumulated, accumulator)); }
default <R> Sequence<R> flatMerge( Function<? super T, ? extends Sequence<? extends R>> mapper, Ordering<? super R> ordering ) { return new MergeSequence<>(ordering, this.map(mapper)); }
@Benchmark public void timeFloorUsingCursor(Blackhole blackhole) { final Sequence<Cursor> cursors = new QueryableIndexStorageAdapter(index).makeCursors( null, index.getDataInterval(), VirtualColumns.EMPTY, Granularities.HOUR, false, null ); final List<Long> results = cursors .map(cursor -> { long count = 0L; while (!cursor.isDone()) { count++; cursor.advance(); } return count; }) .toList(); long count = 0L; for (Long result : results) { count += result; } blackhole.consume(count); }
private DateTime getTimeBoundary(StorageAdapter adapter, TimeBoundaryQuery legacyQuery, boolean descending) { final Sequence<Result<DateTime>> resultSequence = QueryRunnerHelper.makeCursorBasedQuery( adapter, legacyQuery.getQuerySegmentSpec().getIntervals(), Filters.toFilter(legacyQuery.getFilter()), VirtualColumns.EMPTY, descending, Granularities.ALL, this.skipToFirstMatching ); final List<Result<DateTime>> resultList = resultSequence.limit(1).toList(); if (resultList.size() > 0) { return resultList.get(0).getValue(); } return null; }
public static <T> Yielder<T> each(final Sequence<T> sequence) { return sequence.toYielder( null, new YieldingAccumulator<T, T>() { @Override public T accumulate(T accumulated, T in) { yield(); return in; } } ); }
@Test public void testConsistentCloseOrder() { final AtomicInteger closed1 = new AtomicInteger(); final AtomicInteger closed2 = new AtomicInteger(); final AtomicInteger counter = new AtomicInteger(); Sequence<Integer> sequence = Sequences .simple(Arrays.asList(1, 2, 3)) .withBaggage(() -> closed1.set(counter.incrementAndGet())) .withBaggage(() -> closed2.set(counter.incrementAndGet())); // Run sequence via accumulate sequence.toList(); Assert.assertEquals(1, closed1.get()); Assert.assertEquals(2, closed2.get()); // Ensure sequence runs via Yielder, because LimitedSequence extends YieldingSequenceBase Sequence<Integer> yieldingSequence = sequence.limit(1); yieldingSequence.toList(); Assert.assertEquals(3, closed1.get()); Assert.assertEquals(4, closed2.get()); } }
private void check(String expected, Sequence<Integer> complex) { List<Integer> combined = complex.toList(); Assert.assertEquals(expected, combined.toString()); Yielder<Integer> yielder = complex.toYielder( null, new YieldingAccumulator<Integer, Integer>() { @Override public Integer accumulate(Integer accumulated, Integer in) { yield(); return in; } } ); List<Integer> combinedByYielder = new ArrayList<>(); while (!yielder.isDone()) { combinedByYielder.add(yielder.get()); yielder = yielder.next(null); } Assert.assertEquals(expected, combinedByYielder.toString()); }
@Test public void testConsistentEffectApplicationOrder() { final AtomicInteger effect1 = new AtomicInteger(); final AtomicInteger effect2 = new AtomicInteger(); final AtomicInteger counter = new AtomicInteger(); Sequence<Integer> sequence = Sequences .simple(Arrays.asList(1, 2, 3)) .withEffect( () -> effect1.set(counter.incrementAndGet()), Execs.directExecutor() ) .withEffect( () -> effect2.set(counter.incrementAndGet()), Execs.directExecutor() ); // Run sequence via accumulate sequence.toList(); Assert.assertEquals(1, effect1.get()); Assert.assertEquals(2, effect2.get()); // Ensure sequence runs via Yielder, because LimitedSequence extends YieldingSequenceBase which // implements accumulate() via yielder(). // "Limiting" a sequence of 3 elements with 4 to let effects be executed. If e. g. limit with 1 or 2, effects are // not executed. Sequence<Integer> yieldingSequence = sequence.limit(4); yieldingSequence.toList(); Assert.assertEquals(3, effect1.get()); Assert.assertEquals(4, effect2.get()); }
pQueue = baseSequences.accumulate( pQueue, (queue, in) -> { final Yielder<T> yielder = in.toYielder( null, new YieldingAccumulator<T, T>()
@Test public void testNoSideEffects() { final List<Integer> nums = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); final AtomicLong accumulated = new AtomicLong(0); final Sequence<Integer> seq = Sequences.simple( Iterables.transform( nums, input -> { accumulated.addAndGet(input); return input; } ) ).limit(5); Assert.assertEquals(10, seq.accumulate(0, new IntAdditionAccumulator()).intValue()); Assert.assertEquals(10, accumulated.get()); Assert.assertEquals(10, seq.accumulate(0, new IntAdditionAccumulator()).intValue()); Assert.assertEquals(20, accumulated.get()); }
@Override public Sequence<Row> apply(Sequence<Row> input) { return input.limit(limit); } }
.map(result -> { final BySegmentResultValueClass<T> resultsOfSegment = result.getValue(); final Cache.NamedKey cachePopulatorKey = res = cachePopulator.wrap(res, cacheFn::apply, cache, cachePopulatorKey); return res.map( toolChest.makePreComputeManipulatorFn(downstreamQuery, MetricManipulatorFns.deserializing())::apply ); }) .flatMerge(seq -> seq, query.getResultOrdering());
private static <T> Sequence<T> mergeSequences(Query<T> query, List<Sequence<T>> sequences) { return Sequences.simple(sequences).flatMerge(seq -> seq, query.getResultOrdering()); }
private double compute(final Function<ColumnSelectorFactory, BufferAggregator> aggregatorFactory) { final QueryableIndexStorageAdapter adapter = new QueryableIndexStorageAdapter(index); final Sequence<Cursor> cursors = adapter.makeCursors( null, index.getDataInterval(), VirtualColumns.EMPTY, Granularities.ALL, false, null ); final List<Double> results = cursors .map(cursor -> { final BufferAggregator bufferAggregator = aggregatorFactory.apply(cursor.getColumnSelectorFactory()); bufferAggregator.init(aggregationBuffer, 0); while (!cursor.isDone()) { bufferAggregator.aggregate(aggregationBuffer, 0); cursor.advance(); } final Double dbl = (Double) bufferAggregator.get(aggregationBuffer, 0); bufferAggregator.close(); return dbl; }) .toList(); return Iterables.getOnlyElement(results); }
@Benchmark @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MICROSECONDS) public void read(Blackhole blackhole) { IncrementalIndexStorageAdapter sa = new IncrementalIndexStorageAdapter(incIndex); Sequence<Cursor> cursors = makeCursors(sa, null); Cursor cursor = cursors.limit(1).toList().get(0); List<DimensionSelector> selectors = new ArrayList<>(); selectors.add(makeDimensionSelector(cursor, "dimSequential")); selectors.add(makeDimensionSelector(cursor, "dimZipf")); selectors.add(makeDimensionSelector(cursor, "dimUniform")); selectors.add(makeDimensionSelector(cursor, "dimSequentialHalfNull")); cursor.reset(); while (!cursor.isDone()) { for (DimensionSelector selector : selectors) { IndexedInts row = selector.getRow(); blackhole.consume(selector.lookupName(row.get(0))); } cursor.advance(); } }
@Override public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator) { return provider.get().toYielder(initValue, accumulator); } }
seq.accumulate( 1, new Accumulator<Integer, Integer>() Yielder<Integer> yielder = null; try { yielder = seq.toYielder( 1, new YieldingAccumulator<Integer, Integer>()
@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; } }
return Sequences .simple(sequencesByInterval) .flatMerge(seq -> seq, query.getResultOrdering()); });