Java Table.delete方法代碼示例

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
@Override
public void deleteAllTs(ByteBuffer tableName,
                        ByteBuffer row,
                        ByteBuffer column,
    long timestamp, Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
  Table table = null;
  try {
    table = getTable(tableName);
    Delete delete  = new Delete(getBytes(row));
    addAttributes(delete, attributes);
    byte [][] famAndQf = KeyValue.parseColumn(getBytes(column));
    if (famAndQf.length == 1) {
      delete.deleteFamily(famAndQf[0], timestamp);
    } else {
      delete.deleteColumns(famAndQf[0], famAndQf[1], timestamp);
    }
    table.delete(delete);

  } catch (IOException e) {
    LOG.warn(e.getMessage(), e);
    throw new IOError(Throwables.getStackTraceAsString(e));
  } finally {
    closeTable(table);
  }
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
@Override
public void deleteAllRowTs(
    ByteBuffer tableName, ByteBuffer row, long timestamp,
    Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
  Table table = null;
  try {
    table = getTable(tableName);
    Delete delete  = new Delete(getBytes(row), timestamp);
    addAttributes(delete, attributes);
    table.delete(delete);
  } catch (IOException e) {
    LOG.warn(e.getMessage(), e);
    throw new IOError(Throwables.getStackTraceAsString(e));
  } finally {
    closeTable(table);
  }
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
private void deleteAndWait(byte[] row, Table source, Table... targets)
throws Exception {
  Delete del = new Delete(row);
  source.delete(del);

  Get get = new Get(row);
  for (int i = 0; i < NB_RETRIES; i++) {
    if (i==NB_RETRIES-1) {
      fail("Waited too much time for del replication");
    }
    boolean removedFromAll = true;
    for (Table target : targets) {
      Result res = target.get(get);
      if (res.size() >= 1) {
        LOG.info("Row not deleted");
        removedFromAll = false;
        break;
      }
    }
    if (removedFromAll) {
      break;
    } else {
      Thread.sleep(SLEEP_TIME);
    }
  }
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
/**
 * Does the delete using the passed tableInterface but leaves it open
 *
 * @param tableInterface
 * @param delete
 */
public static void doDelete(final Table tableInterface, final Delete delete) {
    try {
        tableInterface.delete(delete);
    } catch (final Exception e) {
        closeTable(tableInterface);
        throw new HBaseException(e.getMessage(), e);
    }
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
@Override
public int run(String[] args) throws Exception {
  if (args.length != 1) {
    System.out.println("Usage : " + Delete.class.getSimpleName() + " <node to delete>");
    return 0;
  }
  byte[] val = Bytes.toBytesBinary(args[0]);

  org.apache.hadoop.hbase.client.Delete delete
    = new org.apache.hadoop.hbase.client.Delete(val);

  Table table = new HTable(getConf(), getTableName(getConf()));
  table.delete(delete);
  table.close();

  System.out.println("Delete successful");
  return 0;
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
/**
 * delete record
 */
public static void delRecord(String tableName, String rowKey)
        throws IOException {
    Table table = connection.getTable(TableName.valueOf(tableName));
    List list = new ArrayList();
    Delete del = new Delete(rowKey.getBytes());
    list.add(del);
    table.delete(list);
    System.out.println("del recored " + rowKey + " ok.");
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
private void deleteAllRows(final Table table) throws IOException {
    final Scan scan = new Scan();
    final List<Delete> deleteList = new ArrayList<>();
    final ResultScanner results = table.getScanner(scan);
    for (final Result result : results) {
        deleteList.add(new Delete(result.getRow()));
    }
    results.close();
    table.delete(deleteList);
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
@Override
public List<TDelete> deleteMultiple(ByteBuffer table, List<TDelete> deletes) throws TIOError,
    TException {
  Table htable = getTable(table);
  try {
    htable.delete(deletesFromThrift(deletes));
  } catch (IOException e) {
    throw getTIOError(e);
  } finally {
    closeTable(htable);
  }
  return Collections.emptyList();
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
private void deleteAndWaitWithFamily(byte[] row, byte[] fam,
    Table source, Table... targets)
  throws Exception {
  Delete del = new Delete(row);
  del.deleteFamily(fam);
  source.delete(del);

  Get get = new Get(row);
  get.addFamily(fam);
  for (int i = 0; i < NB_RETRIES; i++) {
    if (i==NB_RETRIES-1) {
      fail("Waited too much time for del replication");
    }
    boolean removedFromAll = true;
    for (Table target : targets) {
      Result res = target.get(get);
      if (res.size() >= 1) {
        LOG.info("Row not deleted");
        removedFromAll = false;
        break;
      }
    }
    if (removedFromAll) {
      break;
    } else {
      Thread.sleep(SLEEP_TIME);
    }
  }
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
private void fillTable() throws IOException, InterruptedException {
  Table table = TEST_UTIL.createTable(TABLE_NAME, FAMILIES, 3,
      Bytes.toBytes("row0"), Bytes.toBytes("row99"), NUM_RS);
  Random rand = new Random(19387129L);
  for (int iStoreFile = 0; iStoreFile < 4; ++iStoreFile) {
    for (int iRow = 0; iRow < 100; ++iRow) {
      final byte[] row = Bytes.toBytes("row" + iRow);
      Put put = new Put(row);
      Delete del = new Delete(row);
      for (int iCol = 0; iCol < 10; ++iCol) {
        final byte[] cf = rand.nextBoolean() ? CF1 : CF2;
        final long ts = Math.abs(rand.nextInt());
        final byte[] qual = Bytes.toBytes("col" + iCol);
        if (rand.nextBoolean()) {
          final byte[] value = Bytes.toBytes("value_for_row_" + iRow +
              "_cf_" + Bytes.toStringBinary(cf) + "_col_" + iCol + "_ts_" +
              ts + "_random_" + rand.nextLong());
          put.add(cf, qual, ts, value);
        } else if (rand.nextDouble() < 0.8) {
          del.addColumn(cf, qual, ts);
        } else {
          del.addColumn(cf, qual, ts);
        }
      }
      table.put(put);
      table.delete(del);
    }
  }
  TEST_UTIL.waitUntilAllRegionsAssigned(TABLE_NAME);
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
/**
 * Delete the passed <code>deletes</code> from the <code>hbase:meta</code> table.
 * @param connection connection we're using
 * @param deletes Deletes to add to hbase:meta  This list should support #remove.
 * @throws IOException
 */
public static void deleteFromMetaTable(final Connection connection, final List<Delete> deletes)
  throws IOException {
  Table t = getMetaHTable(connection);
  try {
    t.delete(deletes);
  } finally {
    t.close();
  }
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
private void checkRowAndDelete(Table t, byte[] row, int count) throws IOException {
  Get g = new Get(row);
  Result r = t.get(g);
  assertEquals(count, r.size());
  Delete d = new Delete(row);
  t.delete(d);
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
private void doIndexDelete(final List<IndexDelete> deletes) throws IOException {
  Table temptable = null;
  for (IndexDelete delete : deletes) {
    for (Map.Entry<byte[], Delete> entry : delete.getDeletes().entrySet()) {
      temptable = indexTableMaps.get(entry.getKey());
      temptable.delete(entry.getValue());
    }
  }
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
private void deleteAndWait(byte[] row, Table source, Table target)
    throws Exception {
  Delete del = new Delete(row);
  source.delete(del);
  wait(row, target, true);
}
 

import org.apache.hadoop.hbase.client.Table; //導入方法依賴的package包/類
public void testIncompleteMetaTableReplicaInformation() throws Exception {
  final TableName table = TableName.valueOf("fooTableTest1");
  final int numRegions = 3;
  final int numReplica = 2;
  try {
    // Create a table and let the meta table be updated with the location of the
    // region locations.
    HTableDescriptor desc = new HTableDescriptor(table);
    desc.setRegionReplication(numReplica);
    desc.addFamily(new HColumnDescriptor("family"));
    ADMIN.createTable(desc, Bytes.toBytes("A"), Bytes.toBytes("Z"), numRegions);
    TEST_UTIL.waitTableEnabled(table);
    Set<byte[]> tableRows = new HashSet<byte[]>();
    List<HRegionInfo> hris = MetaTableAccessor.getTableRegions(TEST_UTIL.getZooKeeperWatcher(),
      ADMIN.getConnection(), table);
    for (HRegionInfo hri : hris) {
      tableRows.add(hri.getRegionName());
    }
    ADMIN.disableTable(table);
    // now delete one replica info from all the rows
    // this is to make the meta appear to be only partially updated
    Table metaTable = new HTable(TableName.META_TABLE_NAME, ADMIN.getConnection());
    for (byte[] row : tableRows) {
      Delete deleteOneReplicaLocation = new Delete(row);
      deleteOneReplicaLocation.deleteColumns(HConstants.CATALOG_FAMILY,
        MetaTableAccessor.getServerColumn(1));
      deleteOneReplicaLocation.deleteColumns(HConstants.CATALOG_FAMILY,
        MetaTableAccessor.getSeqNumColumn(1));
      deleteOneReplicaLocation.deleteColumns(HConstants.CATALOG_FAMILY,
        MetaTableAccessor.getStartCodeColumn(1));
      metaTable.delete(deleteOneReplicaLocation);
    }
    metaTable.close();
    // even if the meta table is partly updated, when we re-enable the table, we should
    // get back the desired number of replicas for the regions
    ADMIN.enableTable(table);
    assert(ADMIN.isTableEnabled(table));
    List<HRegionInfo> regions = TEST_UTIL.getMiniHBaseCluster().getMaster()
        .getAssignmentManager().getRegionStates().getRegionsOfTable(table);
    assert(regions.size() == numRegions * numReplica);
  } finally {
    ADMIN.disableTable(table);
    ADMIN.deleteTable(table);
  }
}