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

private Result internalGetFromHTable(Table table, String path, boolean fetchContent, boolean fetchTimestamp)
        throws IOException {
    byte[] rowkey = Bytes.toBytes(path);

    Get get = new Get(rowkey);

    if (!fetchContent && !fetchTimestamp) {
        get.setCheckExistenceOnly(true);
    } else {
        if (fetchContent)
            get.addColumn(B_FAMILY, B_COLUMN);
        if (fetchTimestamp)
            get.addColumn(B_FAMILY, B_COLUMN_TS);
    }

    Result result = table.get(get);
    boolean exists = result != null && (!result.isEmpty() || (result.getExists() != null && result.getExists()));
    return exists ? result : null;
}
 

private void verifyReplicationStuck() throws Exception {
  try (Table normalTable = utility1.getConnection().getTable(NORMAL_TABLE)) {
    Put put = new Put(ROW);
    put.addColumn(FAMILY, QUALIFIER, VALUE);
    normalTable.put(put);
  }
  try (Table normalTable = utility2.getConnection().getTable(NORMAL_TABLE)) {
    for (int i = 0; i < NB_RETRIES; i++) {
      Result result = normalTable.get(new Get(ROW).addColumn(FAMILY, QUALIFIER));
      if (result != null && !result.isEmpty()) {
        fail("Edit should have been stuck behind dropped tables, but value is " + Bytes
            .toString(result.getValue(FAMILY, QUALIFIER)));
      } else {
        LOG.info("Row not replicated, let's wait a bit more...");
        Thread.sleep(SLEEP_TIME);
      }
    }
  }
}
 

protected final Object parseFamily(String familyName, Result result) {
	if (result.isEmpty()) {
		return null;
	}
	try {
		Field familyField = clazz.getDeclaredField(familyName);
		byte[] familyNameBytes = Bytes.toBytes(familyField.getName());
		if (HBaseUtil.isBaseFamily(familyField)) {
			return parseNotArrayClass(familyField, familyNameBytes, result);
		} else if (HBaseUtil.isArrayFamily(familyField)) {
			byte[] countBytes = result.getValue(familyNameBytes, COUNT_COLUMN_BYTE_ARRAY);
			if (countBytes != null) {
				int count = Bytes.toInt(countBytes);
				Map<byte[], byte[]> familyMap = result.getFamilyMap(familyNameBytes);
				if (familyMap != null) {
					return parseArrayClass(familyField, count, familyMap);
				}
			}
		} else {
			LogUtil.warn(LOGGER, "������ݿ��ѯ���ʱ��������[" + familyField.getName() + "]");
		}
		return null;
	} catch (Exception cause) {
		throw new RuntimeException(cause);
	}
}
 

/**
 * Add backup set (list of tables)
 * @param name set name
 * @param newTables list of tables, comma-separated
 * @throws IOException if a table operation fails
 */
public void addToBackupSet(String name, String[] newTables) throws IOException {
  if (LOG.isTraceEnabled()) {
    LOG.trace("Backup set add: " + name + " tables [" + StringUtils.join(newTables, " ") + "]");
  }
  String[] union = null;
  try (Table table = connection.getTable(tableName)) {
    Get get = createGetForBackupSet(name);
    Result res = table.get(get);
    if (res.isEmpty()) {
      union = newTables;
    } else {
      res.advance();
      String[] tables = cellValueToBackupSet(res.current());
      union = merge(tables, newTables);
    }
    Put put = createPutForBackupSet(name, union);
    table.put(put);
  }
}
 

private void familyQualifierBasedDeletion(HBaseTransaction tx, Put deleteP, Get deleteG) throws IOException {
    Result result = this.get(tx, deleteG);
    if (!result.isEmpty()) {
        for (Entry<byte[], NavigableMap<byte[], NavigableMap<Long, byte[]>>> entryF : result.getMap()
                .entrySet()) {
            byte[] family = entryF.getKey();
            for (Entry<byte[], NavigableMap<Long, byte[]>> entryQ : entryF.getValue().entrySet()) {
                byte[] qualifier = entryQ.getKey();
                addWriteSetElement(tx, new HBaseCellId(this, deleteP.getRow(), family, qualifier,
                        tx.getWriteTimestamp()));
            }
            deleteP.addColumn(family, CellUtils.FAMILY_DELETE_QUALIFIER, tx.getWriteTimestamp(),
                    CellUtils.DELETE_TOMBSTONE);
            addWriteSetElement(tx, new HBaseCellId(this, deleteP.getRow(), family, CellUtils.FAMILY_DELETE_QUALIFIER,
                                            tx.getWriteTimestamp()));
        }
    }
}
 

private ManagedUser hbaseRowToUser(Result result) throws JsonParseException, JsonMappingException, IOException {
    if (null == result || result.isEmpty())
        return null;

    String username = Bytes.toString(result.getRow());

    byte[] valueBytes = result.getValue(Bytes.toBytes(AclConstant.USER_AUTHORITY_FAMILY),
            Bytes.toBytes(AclConstant.USER_AUTHORITY_COLUMN));
    UserGrantedAuthority[] deserialized = ugaSerializer.deserialize(valueBytes);

    String password = "";
    List<UserGrantedAuthority> authorities = Collections.emptyList();

    // password is stored at [0] of authorities for backward compatibility
    if (deserialized != null) {
        if (deserialized.length > 0 && deserialized[0].getAuthority().startsWith(AclConstant.PWD_PREFIX)) {
            password = deserialized[0].getAuthority().substring(AclConstant.PWD_PREFIX.length());
            authorities = Arrays.asList(deserialized).subList(1, deserialized.length);
        } else {
            authorities = Arrays.asList(deserialized);
        }
    }
    return new ManagedUser(username, password, false, authorities);
}
 

private void verifyReplicationStuck() throws Exception {
  try (Table normalTable = utility1.getConnection().getTable(TABLE)) {
    Put put = new Put(ROW);
    put.addColumn(NORMAL_FAMILY, QUALIFIER, VALUE);
    normalTable.put(put);
  }
  try (Table normalTable = utility2.getConnection().getTable(TABLE)) {
    for (int i = 0; i < NB_RETRIES; i++) {
      Result result = normalTable.get(new Get(ROW).addColumn(NORMAL_FAMILY, QUALIFIER));
      if (result != null && !result.isEmpty()) {
        fail("Edit should have been stuck behind dropped tables, but value is " + Bytes
            .toString(result.getValue(NORMAL_FAMILY, QUALIFIER)));
      } else {
        LOG.info("Row not replicated, let's wait a bit more...");
        Thread.sleep(SLEEP_TIME);
      }
    }
  }
}
 

public RowIterator(Result... results) {
    this.resultScanner = null;
    List<Result> rs = new ArrayList<>(results.length);
    for (Result result : results) {
        // Get by Ids may return empty result
        if (!result.isEmpty()) {
            rs.add(result);
        }
    }
    this.results = rs.iterator();
}
 

@Override
    public List<AcceptApplication> mapRow(Result result, int rowNum) throws Exception {
        if (result.isEmpty()) {
            return Collections.emptyList();
        }
//       readRowKey(result.getRow());

        final List<AcceptApplication> acceptApplicationList = new ArrayList<>(result.size());
        for (Cell cell : result.rawCells()) {
            AcceptApplication acceptedApplication = createAcceptedApplication(cell);
            acceptApplicationList.add(acceptedApplication);
        }
        return acceptApplicationList;
    }
 

/**
 * Reads backup status object (instance of backup info) from backup system table table
 * @param backupId backup id
 * @return Current status of backup session or null
 */
public BackupInfo readBackupInfo(String backupId) throws IOException {
  if (LOG.isTraceEnabled()) {
    LOG.trace("read backup status from backup system table for: " + backupId);
  }

  try (Table table = connection.getTable(tableName)) {
    Get get = createGetForBackupInfo(backupId);
    Result res = table.get(get);
    if (res.isEmpty()) {
      return null;
    }
    return resultToBackupInfo(res);
  }
}
 

@Override
public Application mapRow(Result result, int rowNum) throws Exception {
    if (result.isEmpty()) {
        return null;
    }
    byte[] value = result.value();

    if (value.length != HbaseTableConstatns.APPLICATION_NAME_MAX_LEN + 2) {
        logger.warn("Invalid value. {}", Arrays.toString(value));
    }

    String applicationName = Bytes.toString(value, 0, HbaseTableConstatns.APPLICATION_NAME_MAX_LEN - 1).trim();
    short serviceTypeCode = Bytes.toShort(value, HbaseTableConstatns.APPLICATION_NAME_MAX_LEN);
    return this.applicationFactory.createApplication(applicationName, serviceTypeCode);
}
 

/**
 * Extracts the size component from a serialized {@link SpaceQuotaSnapshot} protobuf.
 *
 * @param r A Result containing one cell with a SpaceQuotaSnapshot protobuf
 * @return The size in bytes of the snapshot.
 */
long getSnapshotSizeFromResult(Result r) throws InvalidProtocolBufferException {
  // Per javadoc, Result should only be null if an exception was thrown. So, if we're here,
  // we should be non-null. If we can't advance to the first cell, same as "no cell".
  if (!r.isEmpty() && r.advance()) {
    return QuotaTableUtil.parseSnapshotSize(r.current());
  }
  return 0L;
}
 

@Override
public Notification getNotification(String notificationId) {
    try {
        String tableName = notificationMapper.getTableName();
        LOG.debug("getting notification with notificationId {} from table {}", notificationId, tableName);
        Get get = new Get(notificationId.getBytes(StandardCharsets.UTF_8));
        Result result = tables.get(tableName).get().get(get);
        return result.isEmpty() ? null : notificationMapper.entity(result);
    } catch (IOException ex) {
        throw new NotificationStoreException("Error getting notification id: " + notificationId, ex);
    }
}
 

/**
 * Validates the current state of the data stored at the end of the test.  Each update by a client consists of two
 * parts: a withdrawal of a random amount from a randomly select other account, and a corresponding to deposit to
 * the client's own account.  So, if all the updates were performed consistently (no partial updates or partial
 * rollbacks), then the total sum of all balances at the end should be 0.
 */
public boolean verify() {
  boolean success = false;
  try {
    TransactionAwareHTable table = new TransactionAwareHTable(conn.getTable(TableName.valueOf(TABLE)));
    TransactionContext context = new TransactionContext(txClient, table);

    LOG.info("VERIFYING BALANCES");
    context.start();
    long totalBalance = 0;

    try (ResultScanner scanner = table.getScanner(new Scan())) {
      for (Result r : scanner) {
        if (!r.isEmpty()) {
          int rowId = Bytes.toInt(r.getRow());
          long balance = Bytes.toLong(r.getValue(FAMILY, COL));
          totalBalance += balance;
          LOG.info("Client #{}: balance = ${}", rowId, balance);
        }
      }
    }
    if (totalBalance == 0) {
      LOG.info("PASSED!");
      success = true;
    } else {
      LOG.info("FAILED! Total balance should be 0 but was {}", totalBalance);
    }
    context.finish();
  } catch (Exception e) {
    LOG.error("Failed verification check", e);
  }
  return success;
}
 

/**
 * Validates the current state of the data stored at the end of the test.  Each update by a client consists of two
 * parts: a withdrawal of a random amount from a randomly select other account, and a corresponding to deposit to
 * the client's own account.  So, if all the updates were performed consistently (no partial updates or partial
 * rollbacks), then the total sum of all balances at the end should be 0.
 */
public boolean verify() {
  boolean success = false;
  try {
    TransactionAwareHTable table = new TransactionAwareHTable(conn.getTable(TableName.valueOf(TABLE)));
    TransactionContext context = new TransactionContext(txClient, table);

    LOG.info("VERIFYING BALANCES");
    context.start();
    long totalBalance = 0;

    try (ResultScanner scanner = table.getScanner(new Scan())) {
      for (Result r : scanner) {
        if (!r.isEmpty()) {
          int rowId = Bytes.toInt(r.getRow());
          long balance = Bytes.toLong(r.getValue(FAMILY, COL));
          totalBalance += balance;
          LOG.info("Client #{}: balance = ${}", rowId, balance);
        }
      }
    }
    if (totalBalance == 0) {
      LOG.info("PASSED!");
      success = true;
    } else {
      LOG.info("FAILED! Total balance should be 0 but was {}", totalBalance);
    }
    context.finish();
  } catch (Exception e) {
    LOG.error("Failed verification check", e);
  }
  return success;
}
 

/**
 * Validates the current state of the data stored at the end of the test.  Each update by a client consists of two
 * parts: a withdrawal of a random amount from a randomly select other account, and a corresponding to deposit to
 * the client's own account.  So, if all the updates were performed consistently (no partial updates or partial
 * rollbacks), then the total sum of all balances at the end should be 0.
 */
public boolean verify() {
  boolean success = false;
  try {
    TransactionAwareHTable table = new TransactionAwareHTable(conn.getTable(TABLE));
    TransactionContext context = new TransactionContext(txClient, table);

    LOG.info("VERIFYING BALANCES");
    context.start();
    long totalBalance = 0;

    try (ResultScanner scanner = table.getScanner(new Scan())) {
      for (Result r : scanner) {
        if (!r.isEmpty()) {
          int rowId = Bytes.toInt(r.getRow());
          long balance = Bytes.toLong(r.getValue(FAMILY, COL));
          totalBalance += balance;
          LOG.info("Client #{}: balance = ${}", rowId, balance);
        }
      }
    }
    if (totalBalance == 0) {
      LOG.info("PASSED!");
      success = true;
    } else {
      LOG.info("FAILED! Total balance should be 0 but was {}", totalBalance);
    }
    context.finish();
  } catch (Exception e) {
    LOG.error("Failed verification check", e);
  }
  return success;
}
 

/**
 * Method to account for the size of retained cells and retained data blocks.
 * @param context rpc call context
 * @param r result to add size.
 * @param lastBlock last block to check whether we need to add the block size in context.
 * @return an object that represents the last referenced block from this response.
 */
Object addSize(RpcCallContext context, Result r, Object lastBlock) {
  if (context != null && r != null && !r.isEmpty()) {
    for (Cell c : r.rawCells()) {
      context.incrementResponseCellSize(PrivateCellUtil.estimatedSerializedSizeOf(c));

      // Since byte buffers can point all kinds of crazy places it's harder to keep track
      // of which blocks are kept alive by what byte buffer.
      // So we make a guess.
      if (c instanceof ByteBufferExtendedCell) {
        ByteBufferExtendedCell bbCell = (ByteBufferExtendedCell) c;
        ByteBuffer bb = bbCell.getValueByteBuffer();
        if (bb != lastBlock) {
          context.incrementResponseBlockSize(bb.capacity());
          lastBlock = bb;
        }
      } else {
        // We're using the last block being the same as the current block as
        // a proxy for pointing to a new block. This won't be exact.
        // If there are multiple gets that bounce back and forth
        // Then it's possible that this will over count the size of
        // referenced blocks. However it's better to over count and
        // use two rpcs than to OOME the regionserver.
        byte[] valueArray = c.getValueArray();
        if (valueArray != lastBlock) {
          context.incrementResponseBlockSize(valueArray.length);
          lastBlock = valueArray;
        }
      }

    }
  }
  return lastBlock;
}
 

@Override
public List<JoinStatBo> mapRow(Result result, int rowNum) throws Exception {
    if (result.isEmpty()) {
        return Collections.emptyList();
    }
    final byte[] distributedRowKey = result.getRow();
    final String applicationId = this.hbaseOperationFactory.getApplicationId(distributedRowKey);
    final long baseTimestamp = this.hbaseOperationFactory.getBaseTimestamp(distributedRowKey);

    List<JoinStatBo> dataPoints = new ArrayList<>();

    for (Cell cell : result.rawCells()) {
        if (CellUtil.matchingFamily(cell, HbaseColumnFamily.APPLICATION_STAT_STATISTICS.getName())) {
            Buffer qualifierBuffer = new OffsetFixedBuffer(cell.getQualifierArray(), cell.getQualifierOffset(), cell.getQualifierLength());
            Buffer valueBuffer = new OffsetFixedBuffer(cell.getValueArray(), cell.getValueOffset(), cell.getValueLength());

            long timestampDelta = this.decoder.decodeQualifier(qualifierBuffer);

            ApplicationStatDecodingContext decodingContext = new ApplicationStatDecodingContext();
            decodingContext.setApplicationId(applicationId);
            decodingContext.setBaseTimestamp(baseTimestamp);
            decodingContext.setTimestampDelta(timestampDelta);
            List<JoinStatBo> candidates = this.decoder.decodeValue(valueBuffer, decodingContext);
            for (JoinStatBo candidate : candidates) {
                long timestamp = candidate.getTimestamp();
                if (this.filter.filter(timestamp)) {
                    continue;
                }
                dataPoints.add(candidate);
            }
        }
    }
    // Reverse sort as timestamp is stored in a reversed order.
    dataPoints.sort(REVERSE_TIMESTAMP_COMPARATOR);
    return dataPoints;
}
 

void compareOneRow(TableMeta tableMeta, Row row, Result r) throws Exception{
	
		if (row == null) {
			throw new Exception("row is null");
		}
		
		byte[] antsKey = KeyBytes.create(row.getKeyAddress()).get();	
		if (r == null || r.isEmpty()) {
			throw new Exception("Row can't be found in hbase - key: " + bytesToHex(antsKey));
		}
		
		// some preparation
		
//	    NavigableMap<byte[], byte[]> sysFamilyMap = r.getFamilyMap(Helper.SYS_COLUMN_FAMILY_BYTES);
	    NavigableMap<byte[], byte[]> dataFamilyMap = r.getFamilyMap(Helper.DATA_COLUMN_FAMILY_BYTES);
//	    byte[] colDataType = sysFamilyMap.get(Helper.SYS_COLUMN_DATATYPE_BYTES);
//	    byte[] versionBytes = sysFamilyMap.get(Helper.SYS_COLUMN_VERSION_BYTES);
//	    byte[] sizeBytes = sysFamilyMap.get(Helper.SYS_COLUMN_SIZE_BYTES);
//	    long version = Bytes.toLong(versionBytes);
//	    int size = Bytes.toInt(sizeBytes);
	    
		byte[] key = Helper.hbaseKeyToAnts(r.getRow());
		if (!Arrays.equals(key, antsKey)) {
			throw new Exception("Row key not match - ANTS: " + bytesToHex(antsKey) + ", HBASE: " + bytesToHex(key));
		}
		
		int maxColumnId = row.getMaxColumnId();
//		byte[] types = new byte[maxColumnId+1];
		String errMsg = "";
        for (int i=0; i<=maxColumnId; i++) {
			byte[] qualifier = tableColumnQualifierList.get(i);
    		if (qualifier == null) {
    			continue;
    		}
    		
        	long pValue = row.getFieldAddress(i); 
    		byte[] antsValue = Helper.toBytes(pValue);
    		byte[] value = dataFamilyMap.get(qualifier);
    		
    		if (!Arrays.equals(antsValue,  value)) {
    			String columnName = new String(qualifier, StandardCharsets.US_ASCII);
    			if (errMsg.length() == 0) {
    				errMsg += "Row Key=[" + bytesToHex(key) + "]";
    			}
    			errMsg += String.format("\n    Column %1$d '%2$s'[%3$s] not match - ANTS:[%4$s] HBASE:[%5$s]",
						i, columnName, bytesToHex(qualifier), bytesToHex(antsValue), bytesToHex(value));
    		}
        }
        
        if (errMsg != "") {
        	throw new Exception(errMsg);
        }
	}
 

/**
 * Returns the list of distinct versions for the given application sorted in
 * reverse chronological order
 *
 * @param cluster
 * @param user
 * @param appId
 * @return the list of versions sorted in reverse chronological order (the
 *         list will be empty if no versions are found)
 * @throws IOException
 */
public List<VersionInfo> getDistinctVersions(String cluster, String user,
    String appId) throws IOException {
  Get get = new Get(getRowKey(cluster, user, appId));
  List<VersionInfo> versions = Lists.newArrayList();
  Long ts = 0L;
  Table versionsTable = null;
  try {
    versionsTable = hbaseConnection
        .getTable(TableName.valueOf(Constants.HISTORY_APP_VERSION_TABLE));
    Result r = versionsTable.get(get);
    if (r != null && !r.isEmpty()) {
      for (Cell c : r.listCells()) {
        ts = 0L;
        try {
          ts = Bytes.toLong(CellUtil.cloneValue(c));
          versions.add(new VersionInfo(
              Bytes.toString(CellUtil.cloneQualifier(c)), ts));
        } catch (IllegalArgumentException e1) {
          // Bytes.toLong may throw IllegalArgumentException, although
          // unlikely.
          LOG.error(
              "Caught conversion error while converting timestamp to long value "
                  + e1.getMessage());
          // rethrow the exception in order to propagate it
          throw e1;
        }
      }
    }

    if (versions.size() > 0) {
      Collections.sort(versions);
    }
  } finally {
    if (versionsTable != null) {
      versionsTable.close();
    }
  }

  return versions;
}