How to use

KuduScanToken$KuduScanTokenBuilder

in

org.apache.kudu.client

    builder.setProjectedColumnIndexes(columnIndexes);
        .map(handle -> ((KuduColumnHandle) handle).getOrdinalPosition())
        .collect(toImmutableList());
    builder.setProjectedColumnIndexes(columnIndexes);
List<KuduScanToken> tokens = builder.build();
return tokens.stream()
    .map(token -> toKuduSplit(tableHandle, token, primaryKeyColumnCount))

builder.addPredicate(KuduPredicate.newIsNullPredicate(columnSchema));
builder.addPredicate(KuduPredicate.newIsNotNullPredicate(columnSchema));
builder.addPredicate(predicate);
  DiscreteValues discreteValues = valueSet.getDiscreteValues();
  KuduPredicate predicate = createInListPredicate(columnSchema, discreteValues);
  builder.addPredicate(predicate);
        ? KuduPredicate.ComparisonOp.GREATER : KuduPredicate.ComparisonOp.GREATER_EQUAL;
    KuduPredicate predicate = createComparisonPredicate(columnSchema, op, low.getValue());
    builder.addPredicate(predicate);
        ? KuduPredicate.ComparisonOp.LESS : KuduPredicate.ComparisonOp.LESS_EQUAL;
    KuduPredicate predicate = createComparisonPredicate(columnSchema, op, high.getValue());
    builder.addPredicate(predicate);

KuduScanToken.KuduScanTokenBuilder builder = apexKuduConnection.getKuduClient().newScanTokenBuilder(
  apexKuduConnection.getKuduTable());
builder = builder.setProjectedColumnNames(new ArrayList<>(
  parsedQuery.getKuduSQLParseTreeListener().getListOfColumnsUsed()));
for (KuduPredicate aPredicate : predicateList) {
 builder = builder.addPredicate(aPredicate);
builder.setFaultTolerant(parentOperator.isFaultTolerantScanner());
Map<String,String> optionsUsedForThisQuery = parentOperator.getOptionsEnabledForCurrentQuery();
if ( optionsUsedForThisQuery.containsKey(KuduSQLParseTreeListener.READ_SNAPSHOT_TIME)) {
 try {
  long readSnapShotTime = Long.valueOf(optionsUsedForThisQuery.get(KuduSQLParseTreeListener.READ_SNAPSHOT_TIME));
  builder = builder.readMode(AsyncKuduScanner.ReadMode.READ_AT_SNAPSHOT);
  builder = builder.snapshotTimestampMicros(readSnapShotTime);
  LOG.info("Using read snapshot for this query as " + readSnapShotTime);
 } catch ( Exception ex) {
List<KuduScanToken> allPossibleScanTokens = builder.build();

builder.addPredicate(KuduPredicate.newIsNullPredicate(columnSchema));
builder.addPredicate(KuduPredicate.newIsNotNullPredicate(columnSchema));
builder.addPredicate(predicate);
  DiscreteValues discreteValues = valueSet.getDiscreteValues();
  KuduPredicate predicate = createInListPredicate(columnSchema, discreteValues);
  builder.addPredicate(predicate);
        ? KuduPredicate.ComparisonOp.GREATER : KuduPredicate.ComparisonOp.GREATER_EQUAL;
    KuduPredicate predicate = createComparisonPredicate(columnSchema, op, low.getValue());
    builder.addPredicate(predicate);
        ? KuduPredicate.ComparisonOp.LESS : KuduPredicate.ComparisonOp.LESS_EQUAL;
    KuduPredicate predicate = createComparisonPredicate(columnSchema, op, high.getValue());
    builder.addPredicate(predicate);

  builder.addPredicate(KuduPredicate.newIsNullPredicate(columnSchema));
} else if (domain.getValues().isAll() && domain.isNullAllowed()) {
  builder.addPredicate(KuduPredicate.newIsNotNullPredicate(columnSchema));
} else if (domain.isSingleValue()) {
  KuduPredicate predicate = createEqualsPredicate(columnSchema, domain.getSingleValue());
  builder.addPredicate(predicate);
} else {
  ValueSet valueSet = domain.getValues();
    DiscreteValues discreteValues = valueSet.getDiscreteValues();
    KuduPredicate predicate = createInListPredicate(columnSchema, discreteValues);
    builder.addPredicate(predicate);
  } else if (valueSet instanceof SortedRangeSet) {
    Ranges ranges = ((SortedRangeSet) valueSet).getRanges();
          ? KuduPredicate.ComparisonOp.GREATER : KuduPredicate.ComparisonOp.GREATER_EQUAL;
      KuduPredicate predicate = createComparisonPredicate(columnSchema, op, low.getValue());
      builder.addPredicate(predicate);
          ? KuduPredicate.ComparisonOp.LESS : KuduPredicate.ComparisonOp.LESS_EQUAL;
      KuduPredicate predicate = createComparisonPredicate(columnSchema, op, high.getValue());
      builder.addPredicate(predicate);

tokenBuilder.setProjectedColumnIndexes(ImmutableList.<Integer>of());
List<KuduScanToken> tokens = tokenBuilder.build();
assertEquals(6, tokens.size());
assertEquals('f' - 'a' + 'z' - 'h',

List<KuduScanToken> tokens = tokenBuilder.build();
assertEquals(1, tokens.size());
KuduScanToken token = tokens.get(0);

tokenBuilder.batchSizeBytes(0);
tokenBuilder.setProjectedColumnIndexes(ImmutableList.<Integer>of());
List<KuduScanToken> tokens = tokenBuilder.build();
assertEquals(16, tokens.size());

List<KuduScanToken> tokens = tokenBuilder.build();
assertEquals(1, tokens.size());
tokens = tokenBuilder.build();
assertEquals(1, tokens.size());
tokens = tokenBuilder.build();
assertEquals(2, tokens.size());

    builder.setProjectedColumnIndexes(columnIndexes);
  } else {
    List<Integer> columnIndexes = desiredColumns.get().stream()
        .map(handle -> ((KuduColumnHandle) handle).getOrdinalPosition())
        .collect(toImmutableList());
    builder.setProjectedColumnIndexes(columnIndexes);
List<KuduScanToken> tokens = builder.build();
return tokens.stream()
    .map(token -> toKuduSplit(tableHandle, token, primaryKeyColumnCount))

    builder.setProjectedColumnIndexes(columnIndexes);
        .map(handle -> ((KuduColumnHandle) handle).getOrdinalPosition())
        .collect(toImmutableList());
    builder.setProjectedColumnIndexes(columnIndexes);
List<KuduScanToken> tokens = builder.build();
return tokens.stream()
    .map(token -> toKuduSplit(tableHandle, token, primaryKeyColumnCount))

 tokenBuilder.addPredicate(predicate);
assertEquals(expectedTablets, tokenBuilder.build().size());

  lower.addByte(i, lowerBoundPrimaryKey[i]);
 scanBuilder.lowerBound(lower);
  upper.addByte(i, upperBoundPrimaryKey[i]);
 scanBuilder.exclusiveUpperBound(upper);
assertEquals(scannedPartitions, scanBuilder.build().size());
assertEquals(expectedTablets == 0 ? 0 : 1, pruner.numRangesRemainingForTests());

 allColumns.add(column.getName());
builder.setProjectedColumnNames(allColumns);
LOG.debug("Building the partition pie assignments for the input operator");
List<KuduScanToken> allPossibleTokens = builder.build();
apexKuduConnection.close();
return allPossibleTokens;

 /**
  * Retrieves this table's range partitions. The range partitions will be returned
  * in sorted order by value, and will contain no duplicates.
  *
  * @param timeout the timeout of the operation
  * @return a list of the formatted range partitions
  */
 @InterfaceAudience.Private
 @InterfaceStability.Unstable
 public List<Partition> getRangePartitions(long timeout) throws Exception {
  // TODO: This could be moved into the RangeSchemaPB returned from server
  // to avoid an extra call to get the range partitions.
  List<Partition> rangePartitions = new ArrayList<>();
  List<KuduScanToken> scanTokens = new KuduScanToken.KuduScanTokenBuilder(client, this)
   .setTimeout(timeout)
   .build();
  for (KuduScanToken token : scanTokens) {
   Partition partition = token.getTablet().getPartition();
   // Filter duplicate range partitions by taking only the tablets whose hash
   // partitions are all 0s.
   if (!Iterators.all(partition.getHashBuckets().iterator(), Predicates.equalTo(0))) {
    continue;
   }
   rangePartitions.add(partition);
  }
  return rangePartitions;
 }
}

/**
 * Collects the rows from a set of scan tokens.
 *
 * @param scanTokens the scan token builder
 * @return the rows
 */
private Set<Row> collectRows(KuduScanToken.KuduScanTokenBuilder scanTokens) throws Exception {
 Set<Row> rows = new HashSet<>();
 for (KuduScanToken token : scanTokens.build()) {
  LOG.debug("Scanning token: {}", KuduScanToken.stringifySerializedToken(token.serialize(),
    client));
  int existingCount = rows.size();
  Set<Row> newRows = collectRows(token.intoScanner(client));
  rows.addAll(newRows);
  assertEquals(existingCount + newRows.size(), rows.size());
 }
 return rows;
}

 /** Test that scanRequestTimeout makes it from the scan token to the underlying Scanner class. */
 @Test
 public void testScanRequestTimeout() throws IOException {
  final int NUM_ROWS_DESIRED = 100;
  final int SCAN_REQUEST_TIMEOUT_MS = 20;
  KuduTable table = createDefaultTable(client, testTableName);
  loadDefaultTable(client, testTableName, NUM_ROWS_DESIRED);
  KuduScanToken.KuduScanTokenBuilder builder =
    new KuduScanToken.KuduScanTokenBuilder(asyncClient, table);
  builder.scanRequestTimeout(SCAN_REQUEST_TIMEOUT_MS);
  List<KuduScanToken> tokens = builder.build();
  for (KuduScanToken token : tokens) {
   byte[] serialized = token.serialize();
   KuduScanner scanner = KuduScanToken.deserializeIntoScanner(serialized, client);
   assertEquals(SCAN_REQUEST_TIMEOUT_MS, scanner.getScanRequestTimeout());
  }
 }
}

public List<KuduScanToken> scanTokens(List<KuduFilterInfo> tableFilters, List<String> tableProjections, Long rowLimit) {
  KuduScanToken.KuduScanTokenBuilder tokenBuilder = client.syncClient().newScanTokenBuilder(table);
  if (CollectionUtils.isNotEmpty(tableProjections)) {
    tokenBuilder.setProjectedColumnNames(tableProjections);
  }
  if (CollectionUtils.isNotEmpty(tableFilters)) {
    tableFilters.stream()
        .map(filter -> filter.toPredicate(table.getSchema()))
        .forEach(tokenBuilder::addPredicate);
  }
  if (rowLimit !=null && rowLimit > 0) {
    tokenBuilder.limit(rowLimit);
    // FIXME: https://issues.apache.org/jira/browse/KUDU-16
    // Server side limit() operator for java-based scanners are not implemented yet
  }
  return tokenBuilder.build();
}

 @Override
 public Void call() throws Exception {
  for (int i = 0; i < 5; i++) {
   try (KuduClient c = new KuduClient.KuduClientBuilder(harness.getMasterAddressesAsString())
     .build()) {
    KuduTable table = c.openTable(TABLE_NAME);
    for (int j = 0; j < 5; j++) {
     KuduScanToken.KuduScanTokenBuilder scanBuilder = c.newScanTokenBuilder(table);
     scanBuilder.build();
     c.asyncClient.emptyTabletsCacheForTable(table.getTableId());
    }
   }
  }
  return null;
 }
}));

/**
 * Retrieves the partitions of a table.
 *
 * @param table the table
 * @return the partitions of the table
 */
private List<Partition> getTablePartitions(KuduTable table) {
 List<Partition> partitions = new ArrayList<>();
 for (KuduScanToken token : client.newScanTokenBuilder(table).build()) {
  partitions.add(token.getTablet().getPartition());
 }
 return partitions;
}