default <R> Sequence<R> flatMerge( Function<? super T, ? extends Sequence<? extends R>> mapper, Ordering<? super R> ordering ) { return new MergeSequence<>(ordering, this.map(mapper)); }
return makeYielder(pQueue, initValue, accumulator);
@Benchmark @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) public void mergeHierarchical(Blackhole blackhole) { Iterator<Sequence<Integer>> iterator = sequences.iterator(); List<Sequence<Integer>> partialMerged = new ArrayList<Sequence<Integer>>(); List<Sequence<Integer>> toMerge = new ArrayList<Sequence<Integer>>(); while (iterator.hasNext()) { toMerge.add(iterator.next()); if (toMerge.size() == mergeAtOnce) { partialMerged.add(new MergeSequence<Integer>(Ordering.natural(), Sequences.simple(toMerge))); toMerge = new ArrayList<Sequence<Integer>>(); } } if (!toMerge.isEmpty()) { partialMerged.add(new MergeSequence<>(Ordering.natural(), Sequences.simple(toMerge))); } MergeSequence<Integer> mergeSequence = new MergeSequence<>( Ordering.natural(), Sequences.simple(partialMerged) ); Integer accumulate = mergeSequence.accumulate(0, Integer::sum); blackhole.consume(accumulate); }
return new MergeSequence<>(queryPlus.getQuery().getResultOrdering(), Sequences.simple(listOfSequences)) .toYielder(initValue, accumulator); } else { return Iterables.getOnlyElement(listOfSequences).toYielder(initValue, accumulator);
return new MergeSequence<>( queryPlus.getQuery().getResultOrdering(), Sequences.simple(listOfSequences)).toYielder( initValue, accumulator );
private <T> MergeSequence<T> makeUnorderedMergedSequence( Ordering<T> ordering, List<TestSequence<T>> seqs ) { return new MergeSequence<T>(ordering, Sequences.simple(seqs)); }
@Benchmark @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) public void mergeFlat(final Blackhole blackhole) { MergeSequence<Integer> mergeSequence = new MergeSequence<>(Ordering.natural(), Sequences.simple(sequences)); Integer accumulate = mergeSequence.accumulate(0, Integer::sum); blackhole.consume(accumulate); } }
return makeYielder(pQueue, initValue, accumulator);
@Override public Sequence<T> run(QueryPlus<T> queryPlus, Map<String, Object> responseContext) { Query query = queryPlus.getQuery(); return new MergeSequence<>( query.getResultOrdering(), Sequences.simple( Lists.transform( optimizer.optimize(query), new Function<Query, Sequence<T>>() { @Override public Sequence<T> apply(Query query) { return runner.run( queryPlus.withQuery(query), responseContext ); } } ) ) ); } }
@Test public void testHierarchicalMerge() throws Exception { final Sequence<Integer> seq1 = new MergeSequence<>( Ordering.natural(), Sequences.simple( Collections.singletonList(TestSequence.create(1)) ) ); final Sequence<Integer> finalMerged = new MergeSequence<>( Ordering.natural(), Sequences.simple( Collections.singletonList(seq1) ) ); SequenceTestHelper.testAll(finalMerged, Collections.singletonList(1)); }
@Test public void testMergeOne() throws Exception { final Sequence<Integer> mergeOne = new MergeSequence<>( Ordering.natural(), Sequences.simple( Collections.singletonList(TestSequence.create(1)) ) ); SequenceTestHelper.testAll(mergeOne, Collections.singletonList(1)); }
@Override public Sequence<T> run(final QueryPlus<T> queryPlus, final Map<String, Object> responseContext) { Query<T> query = queryPlus.getQuery(); DataSource dataSource = query.getDataSource(); if (dataSource instanceof UnionDataSource) { return new MergeSequence<>( query.getResultOrdering(), Sequences.simple( Lists.transform( ((UnionDataSource) dataSource).getDataSources(), new Function<DataSource, Sequence<T>>() { @Override public Sequence<T> apply(DataSource singleSource) { return baseRunner.run( queryPlus.withQuery(query.withDataSource(singleSource)), responseContext ); } } ) ) ); } else { return baseRunner.run(queryPlus, responseContext); } }
@Test public void testWorksWhenBeginningOutOfOrder() throws Exception { final ArrayList<TestSequence<Integer>> testSeqs = Lists.newArrayList( TestSequence.create(2, 8), TestSequence.create(1, 3, 5, 7, 9), TestSequence.create(4, 6, 8) ); MergeSequence<Integer> seq = new MergeSequence<>(Ordering.<Integer>natural(), (Sequence) Sequences.simple(testSeqs)); SequenceTestHelper.testAll(seq, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 8, 9)); for (TestSequence<Integer> sequence : testSeqs) { Assert.assertTrue(sequence.isClosed()); } }
@Test public void testScrewsUpOnOutOfOrder() throws Exception { final ArrayList<TestSequence<Integer>> testSeqs = Lists.newArrayList( TestSequence.create(1, 3, 5, 4, 7, 9), TestSequence.create(2, 8), TestSequence.create(4, 6) ); MergeSequence<Integer> seq = new MergeSequence<>(Ordering.<Integer>natural(), (Sequence) Sequences.simple(testSeqs)); SequenceTestHelper.testAll(seq, Arrays.asList(1, 2, 3, 4, 5, 4, 6, 7, 8, 9)); for (TestSequence<Integer> sequence : testSeqs) { Assert.assertTrue(sequence.isClosed()); } }
@Test public void testSanity() throws Exception { final ArrayList<TestSequence<Integer>> testSeqs = Lists.newArrayList( TestSequence.create(1, 3, 5, 7, 9), TestSequence.create(2, 8), TestSequence.create(4, 6, 8) ); MergeSequence<Integer> seq = new MergeSequence<>(Ordering.<Integer>natural(), (Sequence) Sequences.simple(testSeqs)); SequenceTestHelper.testAll(seq, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 8, 9)); for (TestSequence<Integer> sequence : testSeqs) { Assert.assertTrue(sequence.isClosed()); } }
@Override public Sequence<ScanResultValue> run( QueryPlus<ScanResultValue> queryPlus, Map<String, Object> responseContext ) { // simulate results back from 2 historicals List<Sequence<ScanResultValue>> sequences = Lists.newArrayListWithExpectedSize(2); sequences.add(factory.createRunner(segment0).run(queryPlus, new HashMap<>())); sequences.add(factory.createRunner(segment1).run(queryPlus, new HashMap<>())); return new MergeSequence<>( queryPlus.getQuery().getResultOrdering(), Sequences.simple(sequences) ); } }
@Test public void testMergeEmpties1() throws Exception { final ArrayList<TestSequence<Integer>> testSeqs = Lists.newArrayList( TestSequence.create(), TestSequence.create(1, 3, 5, 7, 9), TestSequence.create(2, 8), TestSequence.create(4, 6, 8) ); MergeSequence<Integer> seq = new MergeSequence<>(Ordering.<Integer>natural(), (Sequence) Sequences.simple(testSeqs)); SequenceTestHelper.testAll(seq, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 8, 9)); for (TestSequence<Integer> sequence : testSeqs) { Assert.assertTrue(sequence.isClosed()); } }
@Test public void testMergeEmpties() throws Exception { final ArrayList<TestSequence<Integer>> testSeqs = Lists.newArrayList( TestSequence.create(1, 3, 5, 7, 9), TestSequence.create(), TestSequence.create(2, 8), TestSequence.create(4, 6, 8) ); MergeSequence<Integer> seq = new MergeSequence<>(Ordering.<Integer>natural(), (Sequence) Sequences.simple(testSeqs)); SequenceTestHelper.testAll(seq, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 8, 9)); for (TestSequence<Integer> sequence : testSeqs) { Assert.assertTrue(sequence.isClosed()); } }
@Test public void testMergeEmpties2() throws Exception { final ArrayList<TestSequence<Integer>> testSeqs = Lists.newArrayList( TestSequence.create(1, 3, 5, 7, 9), TestSequence.create(2, 8), TestSequence.create(), TestSequence.create(4, 6, 8), TestSequence.create() ); MergeSequence<Integer> seq = new MergeSequence<>(Ordering.<Integer>natural(), (Sequence) Sequences.simple(testSeqs)); SequenceTestHelper.testAll(seq, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 8, 9)); for (TestSequence<Integer> sequence : testSeqs) { Assert.assertTrue(sequence.isClosed()); } }
@Override public Sequence<Row> run(QueryPlus<Row> queryPlus, Map<String, Object> responseContext) { // simulate two daily segments final QueryPlus queryPlus1 = queryPlus.withQuerySegmentSpec( new MultipleIntervalSegmentSpec(Collections.singletonList(Intervals.of("2011-04-02/2011-04-03"))) ); final QueryPlus queryPlus2 = queryPlus.withQuerySegmentSpec( new MultipleIntervalSegmentSpec(Collections.singletonList(Intervals.of("2011-04-03/2011-04-04"))) ); return new MergeSequence( queryPlus.getQuery().getResultOrdering(), Sequences.simple( Arrays.asList(runner.run(queryPlus1, responseContext), runner.run(queryPlus2, responseContext)) ) ); } }