private static <T> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
private static <T> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
private static <T> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
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> 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> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
private static <T> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
private static <T> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
private static <T> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
private static <T> List<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
@Override public Sequence run(QueryPlus queryPlus, Map responseContext) { Query realQuery = getRealQuery(queryPlus.getQuery()); return warehouse.getToolChest(realQuery).mergeResults(runner).run(queryPlus.withQuery(realQuery), responseContext); } };
@Override public Sequence<T> apply(Interval singleInterval) { return new AsyncQueryRunner<T>( //Note: it is assumed that toolChest.mergeResults(..) gives a query runner that is //not lazy i.e. it does most of its work on call to run() method toolChest.mergeResults( new MetricsEmittingQueryRunner<T>( emitter, toolChest, baseRunner, QueryMetrics::reportIntervalChunkTime, queryMetrics -> queryMetrics.chunkInterval(singleInterval) ).withWaitMeasuredFromNow() ), executor, queryWatcher ).run( queryPlus.withQuerySegmentSpec( new MultipleIntervalSegmentSpec(Collections.singletonList(singleInterval))), responseContext ); } }
@Benchmark @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MICROSECONDS) public void queryMultiQueryableIndexWithSpilling(Blackhole blackhole) { QueryToolChest<Row, GroupByQuery> toolChest = factory.getToolchest(); QueryRunner<Row> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults( factory.mergeRunners(executorService, makeMultiRunners()) ), (QueryToolChest) toolChest ); final GroupByQuery spillingQuery = query.withOverriddenContext( ImmutableMap.of("bufferGrouperMaxSize", 4000) ); Sequence<Row> queryResult = theRunner.run(QueryPlus.wrap(spillingQuery), new HashMap<>()); List<Row> results = queryResult.toList(); for (Row result : results) { blackhole.consume(result); } }
@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> Iterable<T> runQuery(QueryRunnerFactory factory, QueryRunner runner, Query<T> query) { QueryToolChest toolChest = factory.getToolchest(); QueryRunner<T> theRunner = new FinalizeResultsQueryRunner<>( toolChest.mergeResults(toolChest.preMergeQueryDecoration(runner)), toolChest ); Sequence<T> queryResult = theRunner.run(QueryPlus.wrap(query), new HashMap<>()); return queryResult.toList(); }
@Override public <T> QueryRunner<T> getQueryRunnerForSegments( final Query<T> query, final Iterable<SegmentDescriptor> specs ) { final QueryRunnerFactory<T, Query<T>> factory = conglomerate.findFactory(query); if (factory == null) { throw new ISE("Unknown query type[%s].", query.getClass()); } final QueryToolChest<T, Query<T>> toolChest = factory.getToolchest(); return new FinalizeResultsQueryRunner<>( toolChest.postMergeQueryDecoration( toolChest.mergeResults( toolChest.preMergeQueryDecoration( makeBaseRunner(query, toolChest, factory, specs) ) ) ), toolChest ); }
@Test public void testGroupByWithRegEx() { GroupByQuery.Builder builder = GroupByQuery .builder() .setDataSource(QueryRunnerTestHelper.dataSource) .setInterval("2011-04-02/2011-04-04") .setDimFilter(new RegexDimFilter("quality", "auto.*", null)) .setDimensions(new DefaultDimensionSpec("quality", "quality")) .setAggregatorSpecs(QueryRunnerTestHelper.rowsCount) .setGranularity(new PeriodGranularity(new Period("P1M"), null, null)); final GroupByQuery query = builder.build(); List<Row> expectedResults = Collections.singletonList( GroupByQueryRunnerTestHelper.createExpectedRow("2011-04-01", "quality", "automotive", "rows", 2L) ); QueryRunner<Row> mergeRunner = factory.getToolchest().mergeResults(runner); Map<String, Object> context = new HashMap<>(); TestHelper.assertExpectedObjects(expectedResults, mergeRunner.run(QueryPlus.wrap(query), context), "no-limit"); }
@Override public Sequence<Row> run(QueryPlus<Row> queryPlus, Map<String, Object> responseContext) { // simulate two daily segments final QueryPlus<Row> queryPlus1 = queryPlus.withQuerySegmentSpec( new MultipleIntervalSegmentSpec(Collections.singletonList(Intervals.of("2011-04-02/2011-04-03"))) ); final QueryPlus<Row> queryPlus2 = queryPlus.withQuerySegmentSpec( new MultipleIntervalSegmentSpec(Collections.singletonList(Intervals.of("2011-04-03/2011-04-04"))) ); return factory.getToolchest().mergeResults( (queryPlus3, responseContext1) -> new MergeSequence<>( queryPlus3.getQuery().getResultOrdering(), Sequences.simple( Arrays.asList( runner.run(queryPlus1, responseContext1), runner.run(queryPlus2, responseContext1) ) ) ) ).run(queryPlus, responseContext); } }
@Override public Sequence<Row> run(QueryPlus<Row> queryPlus, Map<String, Object> responseContext) { // simulate two daily segments final QueryPlus<Row> queryPlus1 = queryPlus.withQuerySegmentSpec( new MultipleIntervalSegmentSpec(Collections.singletonList(Intervals.of("2011-04-02/2011-04-03"))) ); final QueryPlus<Row> queryPlus2 = queryPlus.withQuerySegmentSpec( new MultipleIntervalSegmentSpec(Collections.singletonList(Intervals.of("2011-04-03/2011-04-04"))) ); return factory.getToolchest().mergeResults( (queryPlus3, responseContext1) -> new MergeSequence<>( queryPlus3.getQuery().getResultOrdering(), Sequences.simple( Arrays.asList( runner.run(queryPlus1, responseContext1), runner.run(queryPlus2, responseContext1) ) ) ) ).run(queryPlus, responseContext); } }
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(); }