Java Code Examples for org.apache.hadoop.hbase.client.Result#cellScanner()

The following examples show how to use org.apache.hadoop.hbase.client.Result#cellScanner() . These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: hugegraph   File: HbaseSessions.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Just for debug
 */
@SuppressWarnings("unused")
private void dump(String table, Scan scan) throws IOException {
    System.out.println(String.format(">>>> scan table %s with %s",
                                     table, scan));
    RowIterator iterator = this.scan(table, scan);
    while (iterator.hasNext()) {
        Result row = iterator.next();
        System.out.println(StringEncoding.format(row.getRow()));
        CellScanner cellScanner = row.cellScanner();
        while (cellScanner.advance()) {
            Cell cell = cellScanner.current();
            byte[] key = CellUtil.cloneQualifier(cell);
            byte[] val = CellUtil.cloneValue(cell);
            System.out.println(String.format("  %s=%s",
                               StringEncoding.format(key),
                               StringEncoding.format(val)));
        }
    }
}
 
Example 2
Source Project: phoenix   File: TestUtil.java    License: Apache License 2.0 6 votes vote down vote up
public static int getRowCount(Table table, boolean isRaw) throws IOException {
    Scan s = new Scan();
    s.setRaw(isRaw);;
    s.setMaxVersions();
    int rows = 0;
    try (ResultScanner scanner = table.getScanner(s)) {
        Result result = null;
        while ((result = scanner.next()) != null) {
            rows++;
            CellScanner cellScanner = result.cellScanner();
            Cell current = null;
            while (cellScanner.advance()) {
                current = cellScanner.current();
            }
        }
    }
    return rows;
}
 
Example 3
Source Project: phoenix   File: TestUtil.java    License: Apache License 2.0 6 votes vote down vote up
public static CellCount getCellCount(Table table, boolean isRaw) throws IOException {
    Scan s = new Scan();
    s.setRaw(isRaw);;
    s.setMaxVersions();

    CellCount cellCount = new CellCount();
    try (ResultScanner scanner = table.getScanner(s)) {
        Result result = null;
        while ((result = scanner.next()) != null) {
            CellScanner cellScanner = result.cellScanner();
            Cell current = null;
            while (cellScanner.advance()) {
                current = cellScanner.current();
                cellCount.addCell(Bytes.toString(CellUtil.cloneRow(current)));
            }
        }
    }
    return cellCount;
}
 
Example 4
Source Project: hbase   File: TestTags.java    License: Apache License 2.0 6 votes vote down vote up
@Override
public boolean postScannerNext(ObserverContext<RegionCoprocessorEnvironment> e,
    InternalScanner s, List<Result> results, int limit, boolean hasMore) throws IOException {
  if (checkTagPresence) {
    if (results.size() > 0) {
      // Check tag presence in the 1st cell in 1st Result
      Result result = results.get(0);
      CellScanner cellScanner = result.cellScanner();
      if (cellScanner.advance()) {
        Cell cell = cellScanner.current();
        tags = PrivateCellUtil.getTags(cell);
      }
    }
  }
  return hasMore;
}
 
Example 5
protected static void verifyRowFromMap(ImmutableBytesWritable key, Result result)
  throws IOException {
  byte[] row = key.get();
  CellScanner scanner = result.cellScanner();
  while (scanner.advance()) {
    Cell cell = scanner.current();

    //assert that all Cells in the Result have the same key
    Assert.assertEquals(0, Bytes.compareTo(row, 0, row.length,
      cell.getRowArray(), cell.getRowOffset(), cell.getRowLength()));
  }

  for (byte[] family : FAMILIES) {
    byte[] actual = result.getValue(family, family);
    Assert.assertArrayEquals(
      "Row in snapshot does not match, expected:" + Bytes.toString(row) + " ,actual:" + Bytes
        .toString(actual), row, actual);
  }
}
 
Example 6
Source Project: hbase   File: QuotaTableUtil.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Returns a list of {@code Delete} to remove all entries returned by the passed scanner.
 * @param connection connection to re-use
 * @param scan the scanner to use to generate the list of deletes
 */
static List<Delete> createDeletesForExistingSnapshotsFromScan(Connection connection, Scan scan)
    throws IOException {
  List<Delete> deletes = new ArrayList<>();
  try (Table quotaTable = connection.getTable(QUOTA_TABLE_NAME);
      ResultScanner rs = quotaTable.getScanner(scan)) {
    for (Result r : rs) {
      CellScanner cs = r.cellScanner();
      while (cs.advance()) {
        Cell c = cs.current();
        byte[] family = Bytes.copy(c.getFamilyArray(), c.getFamilyOffset(), c.getFamilyLength());
        byte[] qual =
            Bytes.copy(c.getQualifierArray(), c.getQualifierOffset(), c.getQualifierLength());
        Delete d = new Delete(r.getRow());
        d.addColumns(family, qual);
        deletes.add(d);
      }
    }
    return deletes;
  }
}
 
Example 7
Source Project: hbase   File: QuotaTableUtil.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Fetches any persisted HBase snapshot sizes stored in the quota table. The sizes here are
 * computed relative to the table which the snapshot was created from. A snapshot's size will
 * not include the size of files which the table still refers. These sizes, in bytes, are what
 * is used internally to compute quota violation for tables and namespaces.
 *
 * @return A map of snapshot name to size in bytes per space quota computations
 */
public static Map<String,Long> getObservedSnapshotSizes(Connection conn) throws IOException {
  try (Table quotaTable = conn.getTable(QUOTA_TABLE_NAME);
      ResultScanner rs = quotaTable.getScanner(createScanForSpaceSnapshotSizes())) {
    final Map<String,Long> snapshotSizes = new HashMap<>();
    for (Result r : rs) {
      CellScanner cs = r.cellScanner();
      while (cs.advance()) {
        Cell c = cs.current();
        final String snapshot = extractSnapshotNameFromSizeCell(c);
        final long size = parseSnapshotSize(c);
        snapshotSizes.put(snapshot, size);
      }
    }
    return snapshotSizes;
  }
}
 
Example 8
Source Project: hbase   File: QuotaTableUtil.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Returns a multimap for all existing table snapshot entries.
 * @param conn connection to re-use
 */
public static Multimap<TableName, String> getTableSnapshots(Connection conn) throws IOException {
  try (Table quotaTable = conn.getTable(QUOTA_TABLE_NAME);
      ResultScanner rs = quotaTable.getScanner(createScanForSpaceSnapshotSizes())) {
    Multimap<TableName, String> snapshots = HashMultimap.create();
    for (Result r : rs) {
      CellScanner cs = r.cellScanner();
      while (cs.advance()) {
        Cell c = cs.current();

        final String snapshot = extractSnapshotNameFromSizeCell(c);
        snapshots.put(getTableFromRowKey(r.getRow()), snapshot);
      }
    }
    return snapshots;
  }
}
 
Example 9
Source Project: phoenix   File: BaseIndexIT.java    License: Apache License 2.0 6 votes vote down vote up
private void assertNoIndexDeletes(Connection conn, long minTimestamp, String fullIndexName) throws IOException, SQLException {
    if (!this.mutable) {
        PhoenixConnection pconn = conn.unwrap(PhoenixConnection.class);
        PTable index = pconn.getTable(new PTableKey(null, fullIndexName));
        byte[] physicalIndexTable = index.getPhysicalName().getBytes();
        try (Table hIndex = pconn.getQueryServices().getTable(physicalIndexTable)) {
            Scan scan = new Scan();
            scan.setRaw(true);
            if (this.transactional) {
                minTimestamp = TransactionUtil.convertToNanoseconds(minTimestamp);
            }
            scan.setTimeRange(minTimestamp, HConstants.LATEST_TIMESTAMP);
            ResultScanner scanner = hIndex.getScanner(scan);
            Result result;
            while ((result = scanner.next()) != null) {
                CellScanner cellScanner = result.cellScanner();
                while (cellScanner.advance()) {
                    Cell current = cellScanner.current();
                    assertTrue(CellUtil.isPut(current));
                }
            }
        };
    }
}
 
Example 10
Source Project: phoenix   File: TestUtil.java    License: Apache License 2.0 6 votes vote down vote up
public static void dumpTable(Table table) throws IOException {
    System.out.println("************ dumping " + table + " **************");
    Scan s = new Scan();
    s.setRaw(true);;
    s.setMaxVersions();
    try (ResultScanner scanner = table.getScanner(s)) {
        Result result = null;
        while ((result = scanner.next()) != null) {
            CellScanner cellScanner = result.cellScanner();
            Cell current = null;
            while (cellScanner.advance()) {
                current = cellScanner.current();
                System.out.println(current);
            }
        }
    }
    System.out.println("-----------------------------------------------");
}
 
Example 11
Source Project: hugegraph   File: HbaseTable.java    License: Apache License 2.0 5 votes vote down vote up
protected void parseRowColumns(Result row, BackendEntry entry, Query query)
                               throws IOException {
    CellScanner cellScanner = row.cellScanner();
    while (cellScanner.advance()) {
        Cell cell = cellScanner.current();
        entry.columns(BackendColumn.of(CellUtil.cloneQualifier(cell),
                                       CellUtil.cloneValue(cell)));
    }
}
 
Example 12
Source Project: envelope   File: TestHBaseOutput.java    License: Apache License 2.0 5 votes vote down vote up
private void scanAndCountTable(Table table, int expected) throws IOException {
  Scan scan = new Scan();
  ResultScanner scanner = table.getScanner(scan);
  int count = 0;
  for (Result result : scanner) {
    CellScanner cellScanner = result.cellScanner();
    while (cellScanner.advance()) {
      count++;
    }
  }
  assertEquals(expected, count);
}
 
Example 13
Source Project: hbase   File: TableQuotaSnapshotStore.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Fetches any serialized snapshot sizes from the quota table for the {@code tn} provided. Any
 * malformed records are skipped with a warning printed out.
 */
long getSnapshotSizesForTable(TableName tn) throws IOException {
  try (Table quotaTable = conn.getTable(QuotaTableUtil.QUOTA_TABLE_NAME)) {
    Scan s = QuotaTableUtil.createScanForSpaceSnapshotSizes(tn);
    ResultScanner rs = quotaTable.getScanner(s);
    try {
      long size = 0L;
      // Should just be a single row (for our table)
      for (Result result : rs) {
        // May have multiple columns, one for each snapshot
        CellScanner cs = result.cellScanner();
        while (cs.advance()) {
          Cell current = cs.current();
          try {
            long snapshotSize = QuotaTableUtil.parseSnapshotSize(current);
            if (LOG.isTraceEnabled()) {
              LOG.trace("Saw snapshot size of " + snapshotSize + " for " + current);
            }
            size += snapshotSize;
          } catch (InvalidProtocolBufferException e) {
            LOG.warn("Failed to parse snapshot size from cell: " + current);
          }
        }
      }
      return size;
    } finally {
      if (null != rs) {
        rs.close();
      }
    }
  }
}
 
Example 14
Source Project: hbase   File: TestQuotaTableUtil.java    License: Apache License 2.0 5 votes vote down vote up
private void verifyTableSnapshotSize(
    Table quotaTable, TableName tn, String snapshotName, long expectedSize) throws IOException {
  Result r = quotaTable.get(QuotaTableUtil.makeGetForSnapshotSize(tn, snapshotName));
  CellScanner cs = r.cellScanner();
  assertTrue(cs.advance());
  Cell c = cs.current();
  assertEquals(expectedSize, QuotaProtos.SpaceQuotaSnapshot.parseFrom(
      UnsafeByteOperations.unsafeWrap(
          c.getValueArray(), c.getValueOffset(), c.getValueLength())).getQuotaUsage());
  assertFalse(cs.advance());
}
 
Example 15
Source Project: hbase   File: TestQuotaAdmin.java    License: Apache License 2.0 5 votes vote down vote up
private void verifyRecordPresentInQuotaTable(ThrottleType type, long limit, TimeUnit tu,
    QuotaScope scope) throws Exception {
  // Verify the RPC Quotas in the table
  try (Table quotaTable = TEST_UTIL.getConnection().getTable(QuotaTableUtil.QUOTA_TABLE_NAME);
      ResultScanner scanner = quotaTable.getScanner(new Scan())) {
    Result r = Iterables.getOnlyElement(scanner);
    CellScanner cells = r.cellScanner();
    assertTrue("Expected to find a cell", cells.advance());
    assertRPCQuota(type, limit, tu, scope, cells.current());
  }
}
 
Example 16
private long extractSnapshotSize(
    Table quotaTable, TableName tn, String snapshot) throws IOException {
  Get g = QuotaTableUtil.makeGetForSnapshotSize(tn, snapshot);
  Result r = quotaTable.get(g);
  assertNotNull(r);
  CellScanner cs = r.cellScanner();
  assertTrue(cs.advance());
  Cell c = cs.current();
  assertNotNull(c);
  return QuotaTableUtil.extractSnapshotSize(
      c.getValueArray(), c.getValueOffset(), c.getValueLength());
}
 
Example 17
Source Project: hbase   File: PerformanceEvaluation.java    License: Apache License 2.0 5 votes vote down vote up
void updateValueSize(final Result r) throws IOException {
  if (r == null || !isRandomValueSize()) return;
  int size = 0;
  for (CellScanner scanner = r.cellScanner(); scanner.advance();) {
    size += scanner.current().getValueLength();
  }
  updateValueSize(size);
}
 
Example 18
Source Project: hbase   File: QuotaTableUtil.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Returns a set of the names of all namespaces containing snapshot entries.
 * @param conn connection to re-use
 */
public static Set<String> getNamespaceSnapshots(Connection conn) throws IOException {
  try (Table quotaTable = conn.getTable(QUOTA_TABLE_NAME);
      ResultScanner rs = quotaTable.getScanner(createScanForNamespaceSnapshotSizes())) {
    Set<String> snapshots = new HashSet<>();
    for (Result r : rs) {
      CellScanner cs = r.cellScanner();
      while (cs.advance()) {
        cs.current();
        snapshots.add(getNamespaceFromRowKey(r.getRow()));
      }
    }
    return snapshots;
  }
}
 
Example 19
Source Project: phoenix   File: BaseIndexIT.java    License: Apache License 2.0 5 votes vote down vote up
private static void assertShadowCells(Connection conn, String fullTableName, String fullIndexName, boolean exists) 
    throws Exception {
    PTable ptable = conn.unwrap(PhoenixConnection.class).getTable(new PTableKey(null, fullTableName));
    int nTableKVColumns = ptable.getColumns().size() - ptable.getPKColumns().size();
    Table hTable = conn.unwrap(PhoenixConnection.class).getQueryServices().getTable(Bytes.toBytes(fullTableName));
    ResultScanner tableScanner = hTable.getScanner(new Scan());
    Result tableResult;
    PTable pindex = conn.unwrap(PhoenixConnection.class).getTable(new PTableKey(null, fullIndexName));
    int nIndexKVColumns = pindex.getColumns().size() - pindex.getPKColumns().size();
    Table hIndex = conn.unwrap(PhoenixConnection.class).getQueryServices().getTable(Bytes.toBytes(fullIndexName));
    ResultScanner indexScanner = hIndex.getScanner(new Scan());
    Result indexResult;
    while ((indexResult = indexScanner.next()) != null) {
        int nColumns = 0;
        CellScanner scanner = indexResult.cellScanner();
        while (scanner.advance()) {
            nColumns++;
        }
        assertEquals(exists, nColumns > nIndexKVColumns * 2);
        assertNotNull(tableResult = tableScanner.next());
        nColumns = 0;
        scanner = tableResult.cellScanner();
        while (scanner.advance()) {
            nColumns++;
        }
        assertEquals(exists, nColumns > nTableKVColumns * 2);
    }
    assertNull(tableScanner.next());
}
 
Example 20
Source Project: phoenix   File: StatisticsUtil.java    License: Apache License 2.0 4 votes vote down vote up
public static GuidePostsInfo readStatistics(Table statsHTable, GuidePostsKey key, long clientTimeStamp)
        throws IOException {
    ImmutableBytesWritable ptr = new ImmutableBytesWritable();
    ptr.set(key.getColumnFamily());
    byte[] tableNameBytes = key.getPhysicalName();
    byte[] startKey = getStartKey(tableNameBytes, ptr);
    byte[] endKey = getEndKey(tableNameBytes, ptr);
    Scan s = MetaDataUtil.newTableRowsScan(startKey, endKey, MetaDataProtocol.MIN_TABLE_TIMESTAMP, clientTimeStamp);
    s.addColumn(QueryConstants.DEFAULT_COLUMN_FAMILY_BYTES, PhoenixDatabaseMetaData.GUIDE_POSTS_WIDTH_BYTES);
    s.addColumn(QueryConstants.DEFAULT_COLUMN_FAMILY_BYTES, PhoenixDatabaseMetaData.GUIDE_POSTS_ROW_COUNT_BYTES);
    s.addColumn(QueryConstants.DEFAULT_COLUMN_FAMILY_BYTES, QueryConstants.EMPTY_COLUMN_BYTES);
    GuidePostsInfoBuilder guidePostsInfoBuilder = new GuidePostsInfoBuilder();
    Cell current = null;
    GuidePostsInfo emptyGuidePost = null;
    try (ResultScanner scanner = statsHTable.getScanner(s)) {
        Result result = null;
        while ((result = scanner.next()) != null) {
            CellScanner cellScanner = result.cellScanner();
            long rowCount = 0;
            long byteCount = 0;
             while (cellScanner.advance()) {
                current = cellScanner.current();
                if (Bytes.equals(current.getQualifierArray(), current.getQualifierOffset(),
                        current.getQualifierLength(), PhoenixDatabaseMetaData.GUIDE_POSTS_ROW_COUNT_BYTES, 0,
                        PhoenixDatabaseMetaData.GUIDE_POSTS_ROW_COUNT_BYTES.length)) {
                    rowCount = PLong.INSTANCE.getCodec().decodeLong(current.getValueArray(),
                            current.getValueOffset(), SortOrder.getDefault());
                } else if (Bytes.equals(current.getQualifierArray(), current.getQualifierOffset(),
                        current.getQualifierLength(), PhoenixDatabaseMetaData.GUIDE_POSTS_WIDTH_BYTES, 0,
                        PhoenixDatabaseMetaData.GUIDE_POSTS_WIDTH_BYTES.length)) {
                    byteCount = PLong.INSTANCE.getCodec().decodeLong(current.getValueArray(),
                            current.getValueOffset(), SortOrder.getDefault());
                }
            }
            if (current != null) {
                int tableNameLength = tableNameBytes.length + 1;
                int cfOffset = current.getRowOffset() + tableNameLength;
                int cfLength = getVarCharLength(current.getRowArray(), cfOffset,
                        current.getRowLength() - tableNameLength);
                ptr.set(current.getRowArray(), cfOffset, cfLength);
                byte[] cfName = ByteUtil.copyKeyBytesIfNecessary(ptr);
                byte[] newGPStartKey = getGuidePostsInfoFromRowKey(tableNameBytes, cfName, result.getRow());
                boolean isEmptyGuidePost = GuidePostsInfo.isEmptyGpsKey(newGPStartKey);
                // Use the timestamp of the cell as the time at which guidepost was
                // created/updated
                long guidePostUpdateTime = current.getTimestamp();
                if (isEmptyGuidePost) {
                    emptyGuidePost =
                            GuidePostsInfo.createEmptyGuidePost(byteCount, guidePostUpdateTime);
                } else {
                    guidePostsInfoBuilder.trackGuidePost(
                        new ImmutableBytesWritable(newGPStartKey), byteCount, rowCount,
                        guidePostUpdateTime);
                }
            }
        }
    }
    // We write a row with an empty KeyValue in the case that stats were generated but without enough data
    // for any guideposts. If we have no rows, it means stats were never generated.
    return current == null ? GuidePostsInfo.NO_GUIDEPOST : guidePostsInfoBuilder.isEmpty() ? emptyGuidePost : guidePostsInfoBuilder.build();
}