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<>()); }
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(); }
@Benchmark @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MICROSECONDS) public void queryMultiQueryableIndexTopN(Blackhole blackhole) { Sequence<Result<TopNResultValue>> queryResult = topNRunner.run(QueryPlus.wrap(topNQuery), new HashMap<>()); List<Result<TopNResultValue>> results = queryResult.toList(); for (Result<TopNResultValue> result : results) { blackhole.consume(result); } }
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(); }
@Benchmark @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MILLISECONDS) public void queryNative(Blackhole blackhole) { final Sequence<Row> resultSequence = QueryPlus.wrap(groupByQuery).run(walker, new HashMap<>()); final List<Row> resultList = resultSequence.toList(); for (Row row : resultList) { blackhole.consume(row); } }
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(); }
@BenchmarkOptions(warmupRounds = 10000, benchmarkRounds = 10000) @Test public void testmMapped() { testCaseMap.get(TestCases.mMappedTestIndex).run(QueryPlus.wrap(query), context); }
@Test @SuppressWarnings("unchecked") public void testSegmentMetadataQuery() { List<SegmentAnalysis> results = runner1.run(QueryPlus.wrap(testQuery), new HashMap<>()).toList(); Assert.assertEquals(Collections.singletonList(expectedSegmentAnalysis1), results); }
@Ignore @BenchmarkOptions(warmupRounds = 10000, benchmarkRounds = 10000) @Test public void testMerged() { testCaseMap.get(TestCases.mergedRealtimeIndex).run(QueryPlus.wrap(query), context); }
@Ignore @BenchmarkOptions(warmupRounds = 10000, benchmarkRounds = 10000) @Test public void testOffHeap() { testCaseMap.get(TestCases.rtIndexOffheap).run(QueryPlus.wrap(query), context); } }
@Test public void testDefaultNoChunking() { QueryPlus queryPlus = QueryPlus.wrap(queryBuilder.intervals("2014/2016").build()); EasyMock.expect(baseRunner.run(queryPlus, Collections.EMPTY_MAP)).andReturn(Sequences.empty()); EasyMock.replay(baseRunner); QueryRunner runner = decorator.decorate(baseRunner, toolChest); runner.run(queryPlus, Collections.EMPTY_MAP); EasyMock.verify(baseRunner); }
@Test public void testQueryRegistration() { QueryRunner baseRunner = (queryPlus, responseContext) -> null; QueryWatcher mock = EasyMock.createMock(QueryWatcher.class); mock.registerQuery(EasyMock.eq(query), EasyMock.anyObject(ListenableFuture.class)); EasyMock.replay(mock); AsyncQueryRunner asyncRunner = new AsyncQueryRunner<>(baseRunner, executor, mock); asyncRunner.run(QueryPlus.wrap(query), Collections.EMPTY_MAP); EasyMock.verify(mock); } }
@Test public void testChunking() { Query query = queryBuilder.intervals("2015-01-01T00:00:00.000/2015-01-11T00:00:00.000").context(ImmutableMap.of("chunkPeriod", "P1D")).build(); executors.execute(EasyMock.anyObject(Runnable.class)); EasyMock.expectLastCall().times(10); EasyMock.replay(executors); EasyMock.replay(toolChest); QueryRunner runner = decorator.decorate(baseRunner, toolChest); runner.run(QueryPlus.wrap(query), Collections.EMPTY_MAP); EasyMock.verify(executors); }
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(); }
private Sequence<Result<TopNResultValue>> runWithMerge(TopNQuery query, Map<String, Object> context) { final TopNQueryQueryToolChest chest = new TopNQueryQueryToolChest( new TopNQueryConfig(), QueryRunnerTestHelper.NoopIntervalChunkingQueryRunnerDecorator() ); final QueryRunner<Result<TopNResultValue>> mergeRunner = new FinalizeResultsQueryRunner( chest.mergeResults(runner), chest ); return mergeRunner.run(QueryPlus.wrap(query), context); }