public Status scan()

in googlebigtable/src/main/java/site/ycsb/db/GoogleBigtableClient.java [267:351]
74 lines of code
16 McCabe index (conditional complexity)

  public Status scan(String table, String startkey, int recordcount,
      Set<String> fields, Vector<HashMap<String, ByteIterator>> result) {
    setTable(table);
    
    RowFilter filter = RowFilter.newBuilder()
        .setFamilyNameRegexFilterBytes(ByteStringer.wrap(columnFamilyBytes))
        .build();
    if (fields != null && fields.size() > 0) {
      Builder filterChain = RowFilter.Chain.newBuilder();
      filterChain.addFilters(filter);
      filterChain.addFilters(RowFilter.newBuilder()
          .setCellsPerColumnLimitFilter(1)
          .build());
      int count = 0;
      // usually "field#" so pre-alloc
      final StringBuilder regex = new StringBuilder(fields.size() * 6);
      for (final String field : fields) {
        if (count++ > 0) {
          regex.append("|");
        }
        regex.append(field);
      }
      filterChain.addFilters(RowFilter.newBuilder()
          .setColumnQualifierRegexFilter(
              ByteStringer.wrap(regex.toString().getBytes()))).build();
      filter = RowFilter.newBuilder().setChain(filterChain.build()).build();
    }
    
    final RowRange range = RowRange.newBuilder()
        .setStartKeyClosed(ByteStringer.wrap(startkey.getBytes()))
        .build();

    final RowSet rowSet = RowSet.newBuilder()
        .addRowRanges(range)
        .build();

    final ReadRowsRequest.Builder rrr = ReadRowsRequest.newBuilder()
        .setTableNameBytes(ByteStringer.wrap(lastTableBytes))
        .setFilter(filter)
        .setRows(rowSet);
    
    List<Row> rows;
    try {
      rows = client.readRowsAsync(rrr.build()).get();
      if (rows == null || rows.isEmpty()) {
        return Status.NOT_FOUND;
      }
      int numResults = 0;
      
      for (final Row row : rows) {
        final HashMap<String, ByteIterator> rowResult =
            new HashMap<String, ByteIterator>(fields != null ? fields.size() : 10);
        
        for (final Family family : row.getFamiliesList()) {
          if (Arrays.equals(family.getNameBytes().toByteArray(), columnFamilyBytes)) {
            for (final Column column : family.getColumnsList()) {
              // we should only have a single cell per column
              rowResult.put(column.getQualifier().toString(UTF8_CHARSET), 
                  new ByteArrayByteIterator(column.getCells(0).getValue().toByteArray()));
              if (debug) {
                System.out.println(
                    "Result for field: " + column.getQualifier().toString(UTF8_CHARSET)
                        + " is: " + column.getCells(0).getValue().toString(UTF8_CHARSET));
              }
            }
          }
        }
        
        result.add(rowResult);
        
        numResults++;
        if (numResults >= recordcount) {// if hit recordcount, bail out
          break;
        }
      }
      return Status.OK;
    } catch (InterruptedException e) {
      System.err.println("Interrupted during scan: " + e);
      Thread.currentThread().interrupt();
      return Status.ERROR;
    } catch (ExecutionException e) {
      System.err.println("Exception during scan: " + e);
      return Status.ERROR;
    }
  }