@Override public <T> QueryRunner<T> getQueryRunnerForIntervals(final Query<T> query, Iterable<Interval> intervals) { final QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query); final Map<Integer, FireChief> partitionChiefs = chiefs.get(Iterables.getOnlyElement(query.getDataSource() .getNames())); return partitionChiefs == null ? new NoopQueryRunner<T>() : factory.getToolchest().mergeResults( factory.mergeRunners( Execs.directExecutor(), // Chaining query runners which wait on submitted chain query runners can make executor pools deadlock Iterables.transform( partitionChiefs.values(), new Function<FireChief, QueryRunner<T>>() { @Override public QueryRunner<T> apply(FireChief fireChief) { return fireChief.getQueryRunner(query); } } ) ) ); }
private static <T> QueryRunner<T> makeQueryRunner(QueryRunnerFactory<T, Query<T>> factory, Segment adapter) { return new FinalizeResultsQueryRunner<>(factory.createRunner(adapter), factory.getToolchest()); } }
private static <T> Sequence<T> executeQuery(final Injector injector, final QueryableIndex index, final Query<T> query) { final QueryRunnerFactoryConglomerate conglomerate = injector.getInstance(QueryRunnerFactoryConglomerate.class); final QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query); final QueryRunner<T> runner = factory.createRunner(new QueryableIndexSegment(index, SegmentId.dummy("segment"))); return factory .getToolchest() .mergeResults(factory.mergeRunners(Execs.directExecutor(), ImmutableList.of(runner))) .run(QueryPlus.wrap(query), new HashMap<>()); }
@Override public <T> QueryRunner<T> getQueryRunner(Query<T> query) { if (plumber != null) { QueryRunnerFactory<T, Query<T>> factory = queryRunnerFactoryConglomerate.findFactory(query); QueryToolChest<T, Query<T>> toolChest = factory.getToolchest(); return new FinalizeResultsQueryRunner<T>(plumber.getQueryRunner(query), toolChest); } else { return null; } }
@Test public void testMergeRunnersWithLimit() { ScanQuery query = newBuilder().build(); List<ScanResultValue> results = factory .mergeRunners( Execs.directExecutor(), ImmutableList.of(factory.createRunner(segment0), factory.createRunner(segment1)) ) .run(QueryPlus.wrap(query), new HashMap<>()) .toList(); int totalCount = 0; for (ScanResultValue result : results) { System.out.println(((List) result.getEvents()).size()); totalCount += ((List) result.getEvents()).size(); } Assert.assertEquals( totalCount, limit != 0 ? Math.min(limit, V_0112.length + V_0113.length) : V_0112.length + V_0113.length ); }
toolChest.mergeResults( toolChest.preMergeQueryDecoration( factory.mergeRunners( Execs.directExecutor(), Lists.transform(
@Override public QueryRunner apply(final Segment segment) { try { return makeStringSerdeQueryRunner( mapper, toolChest, factory.createRunner(segment) ); } catch (Exception ex) { throw Throwables.propagate(ex); } } }
@Override public <T, QueryType extends Query<T>> QueryToolChest<T, QueryType> getToolChest(final QueryType query) { return conglomerate.findFactory(query).getToolchest(); } },
public static <T, QueryType extends Query<T>> List<T> runQuery( final QueryType query, final QueryRunnerFactory<T, QueryType> factory, final List<QueryableIndex> indexes ) { final Sequence<T> results = new FinalizeResultsQueryRunner<>( factory.getToolchest().mergeResults( factory.mergeRunners( Execs.directExecutor(), FunctionalIterable .create(indexes) .transform( index -> factory.createRunner(new QueryableIndexSegment(index, SegmentId.dummy("xxx"))) ) ) ), (QueryToolChest<T, Query<T>>) factory.getToolchest() ).run(QueryPlus.wrap(query), new HashMap<>()); return results.toList(); }
sinkSegmentId, descriptor.getInterval().getStart(), factory.mergeRunners( Execs.directExecutor(), Iterables.transform(
@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) ); } }
@Override public <T> QueryRunner<T> getQueryRunnerForSegments(final Query<T> query, final Iterable<SegmentDescriptor> specs) { final QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query); final Map<Integer, FireChief> partitionChiefs = chiefs.get(Iterables.getOnlyElement(query.getDataSource() .getNames())); return partitionChiefs == null ? new NoopQueryRunner<T>() : factory.getToolchest().mergeResults( factory.mergeRunners( Execs.directExecutor(), Iterables.transform( specs, new Function<SegmentDescriptor, QueryRunner<T>>() { @Override public QueryRunner<T> apply(SegmentDescriptor spec) { final FireChief retVal = partitionChiefs.get(spec.getPartitionNumber()); return retVal == null ? new NoopQueryRunner<T>() : retVal.getQueryRunner(query.withQuerySegmentSpec(new SpecificSegmentSpec(spec))); } } ) ) ); }
public static <T, QueryType extends Query<T>> QueryRunner<T> makeQueryRunner( QueryRunnerFactory<T, QueryType> factory, SegmentId segmentId, Segment adapter ) { return new FinalizeResultsQueryRunner<>( new BySegmentQueryRunner<>(segmentId, adapter.getDataInterval().getStart(), factory.createRunner(adapter)), (QueryToolChest<T, Query<T>>) factory.getToolchest() ); }
private List<QueryRunner<Row>> makeMultiRunners() { List<QueryRunner<Row>> runners = new ArrayList<>(); for (int i = 0; i < numSegments; i++) { String segmentName = "qIndex" + i; QueryRunner<Row> runner = QueryBenchmarkUtil.makeQueryRunner( factory, SegmentId.dummy(segmentName), new QueryableIndexSegment(queryableIndexes.get(i), SegmentId.dummy(segmentName)) ); runners.add(factory.getToolchest().preMergeQueryDecoration(runner)); } return runners; } }
private static <T> Sequence<T> executeQuery(final Injector injector, final QueryableIndex index, final Query<T> query) { final QueryRunnerFactoryConglomerate conglomerate = injector.getInstance(QueryRunnerFactoryConglomerate.class); final QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query); final QueryRunner<T> runner = factory.createRunner(new QueryableIndexSegment("segment", index)); return factory .getToolchest() .mergeResults(factory.mergeRunners(MoreExecutors.sameThreadExecutor(), ImmutableList.of(runner))) .run(QueryPlus.wrap(query), Maps.newHashMap()); }
factory.mergeRunners( Execs.directExecutor(), FunctionalIterable
@Override public Sequence<T> run(final QueryPlus<T> queryPlus, Map<String, Object> responseContext) { if (adapter.increment()) { try { final Sequence<T> baseSequence = factory.createRunner(adapter).run(queryPlus, responseContext); return Sequences.withBaggage(baseSequence, adapter.decrementOnceCloseable()); } catch (Throwable t) { try { adapter.decrement(); } catch (Exception e) { t.addSuppressed(e); } throw t; } } else { // Segment was closed before we had a chance to increment the reference count return new ReportTimelineMissingSegmentQueryRunner<T>(descriptor).run(queryPlus, responseContext); } } }
@Benchmark @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MICROSECONDS) public void queryMultiQueryableIndex(Blackhole blackhole) { QueryToolChest<Row, GroupByQuery> toolChest = factory.getToolchest(); QueryRunner<Row> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults( factory.mergeRunners(executorService, makeMultiRunners()) ), (QueryToolChest) toolChest ); Sequence<Row> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); List<Row> results = queryResult.toList(); for (Row result : results) { blackhole.consume(result); } }
public static <T> QueryRunner<T> makeTimeBoundaryQueryRunner(Segment adapter) { QueryRunnerFactory factory = new TimeBoundaryQueryRunnerFactory(QueryRunnerTestHelper.NOOP_QUERYWATCHER); return new FinalizeResultsQueryRunner<T>( factory.createRunner(adapter), factory.getToolchest() ); } }
public <T> QueryRunner<T> getQueryRunner(Query<T> query) { QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query); QueryToolChest<T, Query<T>> toolChest = factory.getToolchest(); return new FinalizeResultsQueryRunner<T>(plumber.getQueryRunner(query), toolChest); } }