How to use

MultipleSpecificSegmentSpec

in

org.apache.druid.query.spec

private static Sequence<SegmentAnalysis> runSegmentMetadataQuery(
  final QueryLifecycleFactory queryLifecycleFactory,
  final Iterable<DataSegment> segments,
  final AuthenticationResult authenticationResult
)
{
 // Sanity check: getOnlyElement of a set, to ensure all segments have the same dataSource.
 final String dataSource = Iterables.getOnlyElement(
   StreamSupport.stream(segments.spliterator(), false)
          .map(DataSegment::getDataSource).collect(Collectors.toSet())
 );
 final MultipleSpecificSegmentSpec querySegmentSpec = new MultipleSpecificSegmentSpec(
   StreamSupport.stream(segments.spliterator(), false)
          .map(DataSegment::toDescriptor).collect(Collectors.toList())
 );
 final SegmentMetadataQuery segmentMetadataQuery = new SegmentMetadataQuery(
   new TableDataSource(dataSource),
   querySegmentSpec,
   new AllColumnIncluderator(),
   false,
   ImmutableMap.of(),
   EnumSet.noneOf(SegmentMetadataQuery.AnalysisType.class),
   false,
   false
 );
 return queryLifecycleFactory.factorize().runSimple(segmentMetadataQuery, authenticationResult, null);
}

} else if ((int) context.get("count") == 1) {
 Assert.assertTrue("Should retry with 2 missing segments", ((MultipleSpecificSegmentSpec) ((BaseQuery) query).getQuerySegmentSpec()).getDescriptors().size() == 2);
} else {
 Assert.assertTrue("Should retry with 1 missing segments", ((MultipleSpecificSegmentSpec) ((BaseQuery) query).getQuerySegmentSpec()).getDescriptors().size() == 1);

new MultipleSpecificSegmentSpec(
  missingSegments

private Sequence<Result<TimeseriesResultValue>> toFilteredQueryableTimeseriesResults(
  TimeseriesQuery query,
  List<SegmentId> segmentIds,
  List<Interval> queryIntervals,
  List<Iterable<Result<TimeseriesResultValue>>> results
)
{
 MultipleSpecificSegmentSpec spec = (MultipleSpecificSegmentSpec) query.getQuerySegmentSpec();
 List<Result<TimeseriesResultValue>> ret = new ArrayList<>();
 for (SegmentDescriptor descriptor : spec.getDescriptors()) {
  SegmentId id = SegmentId.dummy(
    StringUtils.format("%s_%s", queryIntervals.indexOf(descriptor.getInterval()), descriptor.getPartitionNumber())
  );
  int index = segmentIds.indexOf(id);
  if (index != -1) {
   Result result = new Result(
     results.get(index).iterator().next().getTimestamp(),
     new BySegmentResultValueClass(
       Lists.newArrayList(results.get(index)),
       id.toString(),
       descriptor.getInterval()
     )
   );
   ret.add(result);
  } else {
   throw new ISE("Descriptor %s not found in server", id);
  }
 }
 return Sequences.simple(ret);
}

private void addSequencesFromServer(
  final List<Sequence<T>> listOfSequences,
  final SortedMap<DruidServer, List<SegmentDescriptor>> segmentsByServer
)
{
 segmentsByServer.forEach((server, segmentsOfServer) -> {
  final QueryRunner serverRunner = serverView.getQueryRunner(server);
  if (serverRunner == null) {
   log.error("Server[%s] doesn't have a query runner", server);
   return;
  }
  final MultipleSpecificSegmentSpec segmentsOfServerSpec = new MultipleSpecificSegmentSpec(segmentsOfServer);
  // Divide user-provided maxQueuedBytes by the number of servers, and limit each server to that much.
  final long maxQueuedBytes = QueryContexts.getMaxQueuedBytes(query, httpClientConfig.getMaxQueuedBytes());
  final long maxQueuedBytesPerServer = maxQueuedBytes / segmentsByServer.size();
  final Sequence<T> serverResults;
  if (isBySegment) {
   serverResults = getBySegmentServerResults(serverRunner, segmentsOfServerSpec, maxQueuedBytesPerServer);
  } else if (!server.segmentReplicatable() || !populateCache) {
   serverResults = getSimpleServerResults(serverRunner, segmentsOfServerSpec, maxQueuedBytesPerServer);
  } else {
   serverResults = getAndCacheServerResults(serverRunner, segmentsOfServerSpec, maxQueuedBytesPerServer);
  }
  listOfSequences.add(serverResults);
 });
}

    new SegmentDescriptor(Intervals.of("2011-11-01/2011-11-10"), "2", 10)
  ),
  ((MultipleSpecificSegmentSpec) spec).getDescriptors()
);

new MultipleSpecificSegmentSpec(
  ImmutableList.of(
    new SegmentDescriptor(
new MultipleSpecificSegmentSpec(
  ImmutableList.of(
    new SegmentDescriptor(
new MultipleSpecificSegmentSpec(
  ImmutableList.of(
    new SegmentDescriptor(

descriptors.add(new SegmentDescriptor(interval2, "v", 5));
descriptors.add(new SegmentDescriptor(interval3, "v", 6));
MultipleSpecificSegmentSpec expected = new MultipleSpecificSegmentSpec(descriptors);

.setDataSource(QueryRunnerTestHelper.dataSource)
.setQuerySegmentSpec(
  new MultipleSpecificSegmentSpec(
    ImmutableList.of(
      descriptor_26_28_0,

private static Sequence<SegmentAnalysis> runSegmentMetadataQuery(
  final QueryLifecycleFactory queryLifecycleFactory,
  final Iterable<DataSegment> segments,
  final AuthenticationResult authenticationResult
)
{
 // Sanity check: getOnlyElement of a set, to ensure all segments have the same dataSource.
 final String dataSource = Iterables.getOnlyElement(
   StreamSupport.stream(segments.spliterator(), false)
          .map(DataSegment::getDataSource).collect(Collectors.toSet())
 );
 final MultipleSpecificSegmentSpec querySegmentSpec = new MultipleSpecificSegmentSpec(
   StreamSupport.stream(segments.spliterator(), false)
          .map(DataSegment::toDescriptor).collect(Collectors.toList())
 );
 final SegmentMetadataQuery segmentMetadataQuery = new SegmentMetadataQuery(
   new TableDataSource(dataSource),
   querySegmentSpec,
   new AllColumnIncluderator(),
   false,
   ImmutableMap.of(),
   EnumSet.noneOf(SegmentMetadataQuery.AnalysisType.class),
   false,
   false
 );
 return queryLifecycleFactory.factorize().runSimple(segmentMetadataQuery, authenticationResult, null);
}

new MultipleSpecificSegmentSpec(
  missingSegments

private void addSequencesFromServer(
  final List<Sequence<T>> listOfSequences,
  final SortedMap<DruidServer, List<SegmentDescriptor>> segmentsByServer
)
{
 segmentsByServer.forEach((server, segmentsOfServer) -> {
  final QueryRunner serverRunner = serverView.getQueryRunner(server);
  if (serverRunner == null) {
   log.error("Server[%s] doesn't have a query runner", server);
   return;
  }
  final MultipleSpecificSegmentSpec segmentsOfServerSpec = new MultipleSpecificSegmentSpec(segmentsOfServer);
  // Divide user-provided maxQueuedBytes by the number of servers, and limit each server to that much.
  final long maxQueuedBytes = QueryContexts.getMaxQueuedBytes(query, httpClientConfig.getMaxQueuedBytes());
  final long maxQueuedBytesPerServer = maxQueuedBytes / segmentsByServer.size();
  final Sequence<T> serverResults;
  if (isBySegment) {
   serverResults = getBySegmentServerResults(serverRunner, segmentsOfServerSpec, maxQueuedBytesPerServer);
  } else if (!server.segmentReplicatable() || !populateCache) {
   serverResults = getSimpleServerResults(serverRunner, segmentsOfServerSpec, maxQueuedBytesPerServer);
  } else {
   serverResults = getAndCacheServerResults(serverRunner, segmentsOfServerSpec, maxQueuedBytesPerServer);
  }
  listOfSequences.add(serverResults);
 });
}