private void addIterator(List<PeekingResultIterator> parentIterators, List<PeekingResultIterator> childIterators) throws SQLException { if (!childIterators.isEmpty()) { if (plan.useRoundRobinIterator()) { /* * When using a round robin iterator we shouldn't concatenate the iterators together. This is because a * round robin iterator should be calling next() on these iterators directly after selecting them in a * round robin fashion. This helps take advantage of loading the underlying scanners' caches in parallel * as well as preventing errors arising out of scanner lease expirations. */ parentIterators.addAll(childIterators); } else { parentIterators.add(ConcatResultIterator.newIterator(childIterators)); } } }
public static PeekingResultIterator newIterator(final List<PeekingResultIterator> concatIterators) { if (concatIterators.isEmpty()) { return PeekingResultIterator.EMPTY_ITERATOR; } if (concatIterators.size() == 1) { return concatIterators.get(0); } return new ConcatResultIterator(concatIterators); } }
@Override public Tuple next() throws SQLException { Tuple next = currentIterator().next(); if (next == null) { close(); // Close underlying ResultIterators to free resources sooner rather than later } return next; }
@Override public Tuple peek() throws SQLException { return currentIterator().peek(); }
private PeekingResultIterator currentIterator() throws SQLException { List<PeekingResultIterator> iterators = getIterators(); while (index < iterators.size()) { PeekingResultIterator iterator = iterators.get(index); Tuple r = iterator.peek(); if (r != null) { return iterator; } iterator.close(); index++; } return EMPTY_ITERATOR; }
@Override public Tuple peek() throws SQLException { return currentIterator().peek(); }
private PeekingResultIterator currentIterator() throws SQLException { List<PeekingResultIterator> iterators = getIterators(); while (index < iterators.size()) { PeekingResultIterator iterator = iterators.get(index); Tuple r = iterator.peek(); if (r != null) { return iterator; } iterator.close(); index++; } return EMPTY_ITERATOR; }
: ConcatResultIterator.newIterator(iterators); if (queryPlan.getContext().getSequenceManager().getSequenceCount() > 0) { iterator = new SequenceResultIterator(iterator, queryPlan.getContext()
@Override public final ResultIterator iterator(ParallelScanGrouper scanGrouper, Scan scan) throws SQLException { this.iterators = new UnionResultIterators(plans, parentContext); ResultIterator scanner; boolean isOrdered = !orderBy.getOrderByExpressions().isEmpty(); if (isOrdered) { // TopN scanner = new MergeSortTopNResultIterator(iterators, limit, offset, orderBy.getOrderByExpressions()); } else { scanner = new ConcatResultIterator(iterators); if (offset != null) { scanner = new OffsetResultIterator(scanner, offset); } if (limit != null) { scanner = new LimitingResultIterator(scanner, limit); } } return scanner; }
@Override public Tuple next() throws SQLException { Tuple next = currentIterator().next(); if (next == null) { close(); // Close underlying ResultIterators to free resources sooner rather than later } return next; }
@Override public Tuple peek() throws SQLException { return currentIterator().peek(); }
private PeekingResultIterator currentIterator() throws SQLException { List<PeekingResultIterator> iterators = getIterators(); while (index < iterators.size()) { PeekingResultIterator iterator = iterators.get(index); Tuple r = iterator.peek(); if (r != null) { return iterator; } iterator.close(); index++; } return EMPTY_ITERATOR; }
ResultIterator iterator = queryPlan.useRoundRobinIterator() ? RoundRobinResultIterator.newIterator(iterators, queryPlan) : ConcatResultIterator.newIterator(iterators); if(queryPlan.getContext().getSequenceManager().getSequenceCount() > 0) { iterator = new SequenceResultIterator(iterator, queryPlan.getContext().getSequenceManager());
@Test public void testConcat() throws Throwable { Tuple[] results1 = new Tuple[] { new SingleKeyValueTuple(new KeyValue(A, SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(1))), }; Tuple[] results2 = new Tuple[] { new SingleKeyValueTuple(new KeyValue(B, SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(2))) }; Tuple[] results3 = new Tuple[] { new SingleKeyValueTuple(new KeyValue(A, SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(3))), new SingleKeyValueTuple(new KeyValue(B, SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(4))), }; final List<PeekingResultIterator>results = Arrays.asList(new PeekingResultIterator[] {new MaterializedResultIterator(Arrays.asList(results1)), new MaterializedResultIterator(Arrays.asList(results2)), new MaterializedResultIterator(Arrays.asList(results3))}); ResultIterators iterators = new MaterializedResultIterators(results); Tuple[] expectedResults = new Tuple[] { new SingleKeyValueTuple(new KeyValue(A, SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(1))), new SingleKeyValueTuple(new KeyValue(B, SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(2))), new SingleKeyValueTuple(new KeyValue(A, SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(3))), new SingleKeyValueTuple(new KeyValue(B, SINGLE_COLUMN_FAMILY, SINGLE_COLUMN, Bytes.toBytes(4))), }; ResultIterator scanner = new ConcatResultIterator(iterators); AssertResults.assertResults(scanner, expectedResults); }
@Override public Tuple next() throws SQLException { Tuple next = currentIterator().next(); if (next == null) { close(); // Close underlying ResultIterators to free resources sooner rather than later } return next; }
iterators.add(peekingResultIterator); ResultIterator iterator = queryPlan.useRoundRobinIterator() ? RoundRobinResultIterator.newIterator(iterators, queryPlan) : ConcatResultIterator.newIterator(iterators); if (queryPlan.getContext().getSequenceManager().getSequenceCount() > 0) { iterator = new SequenceResultIterator(iterator, queryPlan.getContext().getSequenceManager());
public static PeekingResultIterator newIterator(final List<PeekingResultIterator> concatIterators) { if (concatIterators.isEmpty()) { return PeekingResultIterator.EMPTY_ITERATOR; } if (concatIterators.size() == 1) { return concatIterators.get(0); } return new ConcatResultIterator(concatIterators); } }
private void addIterator(List<PeekingResultIterator> parentIterators, List<PeekingResultIterator> childIterators) throws SQLException { if (!childIterators.isEmpty()) { if (plan.useRoundRobinIterator()) { /* * When using a round robin iterator we shouldn't concatenate the iterators together. This is because a * round robin iterator should be calling next() on these iterators directly after selecting them in a * round robin fashion. This helps take advantage of loading the underlying scanners' caches in parallel * as well as preventing errors arising out of scanner lease expirations. */ parentIterators.addAll(childIterators); } else { parentIterators.add(ConcatResultIterator.newIterator(childIterators)); } } }
public static PeekingResultIterator newIterator(final List<PeekingResultIterator> concatIterators) { if (concatIterators.isEmpty()) { return PeekingResultIterator.EMPTY_ITERATOR; } if (concatIterators.size() == 1) { return concatIterators.get(0); } return new ConcatResultIterator(concatIterators); } }
private void addIterator(List<PeekingResultIterator> parentIterators, List<PeekingResultIterator> childIterators) throws SQLException { if (!childIterators.isEmpty()) { if (plan.useRoundRobinIterator()) { /* * When using a round robin iterator we shouldn't concatenate the iterators together. This is because a * round robin iterator should be calling next() on these iterators directly after selecting them in a * round robin fashion. This helps take advantage of loading the underlying scanners' caches in parallel * as well as preventing errors arising out of scanner lease expirations. */ parentIterators.addAll(childIterators); } else { parentIterators.add(ConcatResultIterator.newIterator(childIterators)); } } }