How to use

IncrementalIndexStorageAdapter

in

org.apache.druid.segment.incremental

@Override
public StorageAdapter asStorageAdapter()
{
 return new IncrementalIndexStorageAdapter(index);
}

private Sequence<Cursor> makeCursors(IncrementalIndexStorageAdapter sa, DimFilter filter)
{
 return sa.makeCursors(
   filter.toFilter(),
   schemaInfo.getDataInterval(),
   VirtualColumns.EMPTY,
   Granularities.ALL,
   false,
   null
 );
}

@Override
public String getColumnTypeName(String column)
{
 final String metricType = index.getMetricType(column);
 if (metricType != null) {
  return metricType;
 }
 ColumnCapabilities columnCapabilities = getColumnCapabilities(column);
 if (columnCapabilities != null) {
  return columnCapabilities.getType().toString();
 } else {
  return null;
 }
}

@Override
public Sequence<Cursor> makeCursors(
  @Nullable final Filter filter,
  final Interval interval,
  final VirtualColumns virtualColumns,
  final Granularity gran,
  final boolean descending,
  @Nullable QueryMetrics<?> queryMetrics
)
{
 if (index.isEmpty()) {
  return Sequences.empty();
 }
 final Interval dataInterval = new Interval(getMinTime(), gran.bucketEnd(getMaxTime()));
 if (!interval.overlaps(dataInterval)) {
  return Sequences.empty();
 }
 final Interval actualInterval = interval.overlap(dataInterval);
 Iterable<Interval> intervals = gran.getIterable(actualInterval);
 if (descending) {
  intervals = Lists.reverse(ImmutableList.copyOf(intervals));
 }
 return Sequences
   .simple(intervals)
   .map(i -> new IncrementalIndexCursor(virtualColumns, descending, filter, i, actualInterval, gran));
}

IncrementalIndexStorageAdapter adapter = new IncrementalIndexStorageAdapter(index);
 Sequence<Cursor> cursorSequence = adapter.makeCursors(
   new SelectorFilter("sally", "bo"),
   interval,

final IncrementalIndexStorageAdapter queryable = new IncrementalIndexStorageAdapter(index);
Assert.assertEquals(2, queryable.getAvailableDimensions().size());
Assert.assertEquals("host", queryable.getAvailableDimensions().get(0));
Assert.assertEquals("spatial", queryable.getAvailableDimensions().get(1));
Assert.assertEquals(ImmutableList.of("visited_sum", "unique_hosts"), queryable.getAvailableMetrics());

@Override
public Sequence<Cursor> makeCursors(
  @Nullable final Filter filter,
  final Interval interval,
  final VirtualColumns virtualColumns,
  final Granularity gran,
  final boolean descending,
  @Nullable QueryMetrics<?> queryMetrics
)
{
 if (index.isEmpty()) {
  return Sequences.empty();
 }
 final Interval dataInterval = new Interval(getMinTime(), gran.bucketEnd(getMaxTime()));
 if (!interval.overlaps(dataInterval)) {
  return Sequences.empty();
 }
 final Interval actualInterval = interval.overlap(dataInterval);
 Iterable<Interval> intervals = gran.getIterable(actualInterval);
 if (descending) {
  intervals = Lists.reverse(ImmutableList.copyOf(intervals));
 }
 return Sequences
   .simple(intervals)
   .map(i -> new IncrementalIndexCursor(virtualColumns, descending, filter, i, actualInterval, gran));
}

@Override
public StorageAdapter toStorageAdapter()
{
 return new IncrementalIndexStorageAdapter(this);
}

@Override
public String getColumnTypeName(String column)
{
 final String metricType = index.getMetricType(column);
 if (metricType != null) {
  return metricType;
 }
 ColumnCapabilities columnCapabilities = getColumnCapabilities(column);
 if (columnCapabilities != null) {
  return columnCapabilities.getType().toString();
 } else {
  return null;
 }
}

@Benchmark
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
public void read(Blackhole blackhole)
{
 IncrementalIndexStorageAdapter sa = new IncrementalIndexStorageAdapter(incIndex);
 Sequence<Cursor> cursors = makeCursors(sa, null);
 Cursor cursor = cursors.limit(1).toList().get(0);
 List<DimensionSelector> selectors = new ArrayList<>();
 selectors.add(makeDimensionSelector(cursor, "dimSequential"));
 selectors.add(makeDimensionSelector(cursor, "dimZipf"));
 selectors.add(makeDimensionSelector(cursor, "dimUniform"));
 selectors.add(makeDimensionSelector(cursor, "dimSequentialHalfNull"));
 cursor.reset();
 while (!cursor.isDone()) {
  for (DimensionSelector selector : selectors) {
   IndexedInts row = selector.getRow();
   blackhole.consume(selector.lookupName(row.get(0)));
  }
  cursor.advance();
 }
}

IncrementalIndexStorageAdapter sa = new IncrementalIndexStorageAdapter(incIndex);
Sequence<Cursor> cursors = makeCursors(sa, filter);
Cursor cursor = cursors.limit(1).toList().get(0);

input -> {
 final IncrementalIndex index = input.buildIncrementalIndex();
 return Pair.of(new IncrementalIndexStorageAdapter(index), index);
},
"mmapped",

        .addAggregator(new LongSumAggregatorFactory("cnt", "cnt"))
        .build(),
  new IncrementalIndexStorageAdapter(index)
);

        .setDimFilter(DimFilters.dimEquals("sally", (String) null))
        .build(),
  new IncrementalIndexStorageAdapter(index)
);

  .aggregators(Collections.singletonList(new LongSumAggregatorFactory("cnt", "cnt")))
  .build(),
new IncrementalIndexStorageAdapter(index),
null

  new IncrementalIndexStorageAdapter(index)
);

engine.process(query, new IncrementalIndexStorageAdapter(index)).toList();

engine.process(query, new IncrementalIndexStorageAdapter(index)).toList();

@Override
public StorageAdapter toStorageAdapter()
{
 return new IncrementalIndexStorageAdapter(this);
}

@Override
public StorageAdapter asStorageAdapter()
{
 return new IncrementalIndexStorageAdapter(index);
}