Java Code Examples for org.apache.hadoop.hbase.client.Delete#addFamily()

private static Delete addDeleteMark(Delete d, DeleteMark mark, long now) {
  switch (mark) {
    case ROW:
      break;
    case FAMILY:
      d.addFamily(fam);
      break;
    case FAMILY_VERSION:
      d.addFamilyVersion(fam, now);
      break;
    case COLUMN:
      d.addColumns(fam, qual);
      break;
    case CELL:
      d.addColumn(fam, qual);
      break;
    default:
      break;
  }
  return d;
}
 

@Test
public void testMajorCompactionAfterDelete() throws Exception {
  init(UTIL.getConfiguration(), 100);
  byte[] dummyData = makeDummyData(200); // larger than mob threshold
  Table loader = new RegionAsTable(region);
  // create hfiles and mob hfiles but don't trigger compaction
  int numHfiles = compactionThreshold - 1;
  byte[] deleteRow = Bytes.add(STARTROW, Bytes.toBytes(0));
  for (int i = 0; i < numHfiles; i++) {
    Put p = createPut(i, dummyData);
    loader.put(p);
    region.flush(true);
  }
  assertEquals("Before compaction: store files", numHfiles, countStoreFiles());
  assertEquals("Before compaction: mob file count", numHfiles, countMobFiles());
  assertEquals("Before compaction: rows", numHfiles, UTIL.countRows(region));
  assertEquals("Before compaction: mob rows", numHfiles, countMobRows());
  assertEquals("Before compaction: number of mob cells", numHfiles, countMobCellsInMetadata());
  // now let's delete some cells that contain mobs
  Delete delete = new Delete(deleteRow);
  delete.addFamily(COLUMN_FAMILY);
  region.delete(delete);
  region.flush(true);

  assertEquals("Before compaction: store files", numHfiles + 1, countStoreFiles());
  assertEquals("Before compaction: mob files", numHfiles, countMobFiles());
  // region.compactStores();
  region.compact(true);
  assertEquals("After compaction: store files", 1, countStoreFiles());
}
 

/**
* 数据删除 
* @param tableName 表名
* @param rowKey	行健
* @param family	列族
* @param qualifier 列
* @return
*/
  public static void delete(String tableName, String rowKey, String family,
          String qualifier) {
  	if (null == tableName ||tableName.length()==0) {
	return;
}
if( null == rowKey || rowKey.length() == 0){
	return;
}
  	Table t = null;
      try {
          t = getConnection().getTable(TableName.valueOf(tableName));
          Delete del = new Delete(Bytes.toBytes(rowKey));
          // 如果列族不为空
		if (null != family && family.length() > 0) {
			// 如果列不为空
			if (null != qualifier && qualifier.length() > 0) {
				del.addColumn(Bytes.toBytes(family),
						Bytes.toBytes(qualifier));
			} else {
				del.addFamily(Bytes.toBytes(family));
			}
		}      
          t.delete(del);    
      } catch (IOException e) {
      	System.out.println("删除失败!");
          e.printStackTrace();
      } finally {
        close();
      }
  }
 

@Test
public void testDeleteFamilyWithoutCellVisibilityWithMulipleVersions() throws Exception {
  setAuths();
  final TableName tableName = TableName.valueOf(testName.getMethodName());
  try (Table table = doPutsWithoutVisibility(tableName)) {
    TEST_UTIL.getAdmin().flush(tableName);
    PrivilegedExceptionAction<Void> actiona = new PrivilegedExceptionAction<Void>() {
      @Override
      public Void run() throws Exception {
        try (Connection connection = ConnectionFactory.createConnection(conf);
          Table table = connection.getTable(tableName)) {
          Delete d = new Delete(row1);
          d.addFamily(fam);
          table.delete(d);
        } catch (Throwable t) {
          throw new IOException(t);
        }
        return null;
      }
    };
    SUPERUSER.runAs(actiona);

    TEST_UTIL.getAdmin().flush(tableName);
    Scan s = new Scan();
    s.readVersions(5);
    s.setAuthorizations(new Authorizations(SECRET, PRIVATE, CONFIDENTIAL, TOPSECRET));
    ResultScanner scanner = table.getScanner(s);
    Result[] next = scanner.next(3);
    assertTrue(next.length == 1);
    // All cells wrt row1 should be deleted as we are not passing the Cell Visibility
    CellScanner cellScanner = next[0].cellScanner();
    cellScanner.advance();
    Cell current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row2, 0, row2.length));
  }
}
 

@Test
public void testVisibilityLabelsWithDeleteFamily() throws Exception {
  setAuths();
  final TableName tableName = TableName.valueOf(testName.getMethodName());
  try (Table table = createTableAndWriteDataWithLabels(SECRET, CONFIDENTIAL + "|" + TOPSECRET)) {
    PrivilegedExceptionAction<Void> actiona = new PrivilegedExceptionAction<Void>() {
      @Override
      public Void run() throws Exception {
        try (Connection connection = ConnectionFactory.createConnection(conf);
          Table table = connection.getTable(tableName)) {
          Delete d = new Delete(row2);
          d.setCellVisibility(new CellVisibility(TOPSECRET + "|" + CONFIDENTIAL));
          d.addFamily(fam);
          table.delete(d);
        } catch (Throwable t) {
          throw new IOException(t);
        }
        return null;
      }
    };
    SUPERUSER.runAs(actiona);

    TEST_UTIL.getAdmin().flush(tableName);
    Scan s = new Scan();
    s.setAuthorizations(new Authorizations(SECRET, PRIVATE, CONFIDENTIAL));
    ResultScanner scanner = table.getScanner(s);
    Result[] next = scanner.next(3);
    assertTrue(next.length == 1);
    CellScanner cellScanner = next[0].cellScanner();
    cellScanner.advance();
    Cell current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
  }
}
 

private void delete(Table source, byte[] row, byte[]... families)
    throws Exception {
  for (byte[] fam : families) {
    Delete del = new Delete(row);
    del.addFamily(fam);
    source.delete(del);
  }
}
 

@Test(timeOut = 10_000)
public void runTestDeleteFamilyAborts(ITestContext context) throws Exception {

    TransactionManager tm = newTransactionManager(context);
    TTable tt = new TTable(connection, TEST_TABLE);

    ((HBaseTransactionManager) tm).setConflictDetectionLevel(ConflictDetectionLevel.ROW);

    Transaction t1 = tm.begin();
    LOG.info("Transaction created " + t1);

    int rowsWritten = 10;
    FamCol famColA = new FamCol(famA, colA);
    FamCol famColB = new FamCol(famB, colB);
    writeRows(tt, t1, rowsWritten, famColA, famColB);

    Transaction t2 = tm.begin();

    tm.commit(t1);

    Delete d = new Delete(modrow);
    d.addFamily(famA);
    tt.delete(t2, d);

    try {
        tm.commit(t2);
    } catch(RollbackException e) {
        System.out.println("Rollback");
        System.out.flush();
    }

    Transaction tscan = tm.begin();
    ResultScanner rs = tt.getScanner(tscan, new Scan());

    Map<FamCol, Integer> count = countColsInRows(rs, famColA, famColB);
    assertEquals((int) count.get(famColA), rowsWritten, "ColA count should be equal to rowsWritten");
    assertEquals((int) count.get(famColB), rowsWritten, "ColB count should be equal to rowsWritten");

    ((HBaseTransactionManager) tm).setConflictDetectionLevel(ConflictDetectionLevel.CELL);
}
 

/**
 * Generates and returns a Delete containing the region info for the catalog table
 */
private static Delete makeDeleteFromRegionInfo(RegionInfo regionInfo, long ts) {
  if (regionInfo == null) {
    throw new IllegalArgumentException("Can't make a delete for null region");
  }
  Delete delete = new Delete(regionInfo.getRegionName());
  delete.addFamily(HConstants.CATALOG_FAMILY, ts);
  return delete;
}
 

private void deleteAndWaitWithFamily(byte[] row, byte[] fam,
    Table source, Table... targets)
  throws Exception {
  Delete del = new Delete(row);
  del.addFamily(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);
    }
  }
}
 

/**
 * Creates Delete operation for a given backup id
 * @param backupId backup's ID
 * @return delete operation
 */
private Delete createDeleteForBackupInfo(String backupId) {
  Delete del = new Delete(rowkey(BACKUP_INFO_PREFIX, backupId));
  del.addFamily(BackupSystemTable.SESSIONS_FAMILY);
  return del;
}
 

/**
 * Creates Delete operation to delete backup set content
 * @param name backup set's name
 * @return delete operation
 */
private Delete createDeleteForBackupSet(String name) {
  Delete del = new Delete(rowkey(SET_KEY_PREFIX, name));
  del.addFamily(BackupSystemTable.META_FAMILY);
  return del;
}
 

private Delete createDeleteForBackupMergeOperation() {
  Delete delete = new Delete(MERGE_OP_ROW);
  delete.addFamily(META_FAMILY);
  return delete;
}
 

private static void deleteEntry(Table aclTable, byte[] entry) throws IOException {
  Delete delete = new Delete(entry);
  delete.addFamily(HDFS_ACL_FAMILY);
  aclTable.delete(delete);
}
 

@Test
public void testDeleteFamilyAndDeleteColumnsWithAndWithoutVisibilityExp() throws Exception {
  setAuths();
  final TableName tableName = TableName.valueOf(testName.getMethodName());
  try (Table table = doPuts(tableName)) {
    TEST_UTIL.getAdmin().flush(tableName);
    PrivilegedExceptionAction<Void> actiona = new PrivilegedExceptionAction<Void>() {
      @Override
      public Void run() throws Exception {
        Delete d1 = new Delete(row1);
        d1.addFamily(fam);

        Delete d2 = new Delete(row1);
        d2.setCellVisibility(new CellVisibility(SECRET + "&" + TOPSECRET));
        d2.addColumns(fam, qual);
        try (Connection connection = ConnectionFactory.createConnection(conf);
          Table table = connection.getTable(tableName)) {
          table.delete(createList(d1, d2));
        } catch (Throwable t) {
          throw new IOException(t);
        }
        return null;
      }
    };
    SUPERUSER.runAs(actiona);
    Scan s = new Scan();
    s.readVersions(5);
    s.setAuthorizations(new Authorizations(SECRET, PRIVATE, CONFIDENTIAL, TOPSECRET));
    ResultScanner scanner = table.getScanner(s);
    Result[] next = scanner.next(3);
    assertTrue(next.length == 2);
    CellScanner cellScanner = next[0].cellScanner();
    cellScanner.advance();
    Cell current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
    assertEquals(127L, current.getTimestamp());
    cellScanner.advance();
    current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
    assertEquals(126L, current.getTimestamp());
    cellScanner.advance();
    current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
    assertEquals(124L, current.getTimestamp());
    cellScanner.advance();
    current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
    assertEquals(123L, current.getTimestamp());
    cellScanner = next[1].cellScanner();
    cellScanner.advance();
    current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row2, 0, row2.length));
    scanner.close();
  }
}
 

/**
 * Creates Delete for incremental backup table set
 * @param backupRoot backup root
 * @return delete operation
 */
private Delete createDeleteForIncrBackupTableSet(String backupRoot) {
  Delete delete = new Delete(rowkey(INCR_BACKUP_SET, backupRoot));
  delete.addFamily(BackupSystemTable.META_FAMILY);
  return delete;
}
 

@Test(timeOut = 60_000)
public void testGetWithFamilyDelete() throws Throwable {
    byte[] rowName1 = Bytes.toBytes("row1");
    byte[] famName1 = Bytes.toBytes(TEST_FAMILY);
    byte[] famName2 = Bytes.toBytes("test-fam2");
    byte[] colName1 = Bytes.toBytes("col1");
    byte[] colName2 = Bytes.toBytes("col2");
    byte[] dataValue1 = Bytes.toBytes("testWrite-1");

    String TEST_TABLE = "testGetWithFamilyDelete";
    createTableIfNotExists(TEST_TABLE, Bytes.toBytes(TEST_FAMILY), famName2);

    TTable tt = new TTable(connection, TEST_TABLE);

    Transaction tx1 = tm.begin();

    Put put1 = new Put(rowName1);
    put1.addColumn(famName1, colName1, dataValue1);
    tt.put(tx1, put1);

    tm.commit(tx1);

    Transaction tx2 = tm.begin();
    Put put2 = new Put(rowName1);
    put2.addColumn(famName2, colName2, dataValue1);
    tt.put(tx2, put2);
    tm.commit(tx2);

    Transaction tx3 = tm.begin();

    Delete d = new Delete(rowName1);
    d.addFamily(famName2);
    tt.delete(tx3, d);


    Transaction tx4 = tm.begin();

    Get get = new Get(rowName1);

    Filter filter1 = new FilterList(FilterList.Operator.MUST_PASS_ONE,
            new FamilyFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(Bytes.toBytes(TEST_FAMILY))),
            new FamilyFilter(CompareFilter.CompareOp.EQUAL, new BinaryComparator(famName2)));

    get.setFilter(filter1);
    Result result = tt.get(tx4, get);
    assertTrue(result.size() == 2, "Result should be 2");

    try {
        tm.commit(tx3);
    } catch (RollbackException e) {
        if (!tm.isLowLatency())
            fail();
    }
    Transaction tx5 = tm.begin();
    result = tt.get(tx5, get);
    if (!tm.isLowLatency())
        assertTrue(result.size() == 1, "Result should be 1");

    tt.close();
}
 

@Test
public void testMinorCompactionWithDeleteColumnFamily() throws Exception {
  Delete deleteCF = new Delete(secondRowBytes);
  deleteCF.addFamily(fam2);
  testMinorCompactionWithDelete(deleteCF);
}
 

@Test
public void testScanAfterCompaction() throws Exception {
  setAuths();
  final TableName tableName = TableName.valueOf(testName.getMethodName());
  try (Table table = doPuts(tableName)) {
    TEST_UTIL.getAdmin().flush(tableName);
    PrivilegedExceptionAction<Void> actiona = new PrivilegedExceptionAction<Void>() {
      @Override
      public Void run() throws Exception {
        try (Connection connection = ConnectionFactory.createConnection(conf);
          Table table = connection.getTable(tableName)) {
          Delete d = new Delete(row1);
          d.setCellVisibility(new CellVisibility(
              "(" + PRIVATE + "&" + CONFIDENTIAL + ")|(" + SECRET + "&" + TOPSECRET + ")"));
          d.addFamily(fam, 126L);
          table.delete(d);
        } catch (Throwable t) {
          throw new IOException(t);
        }
        return null;
      }
    };
    SUPERUSER.runAs(actiona);

    TEST_UTIL.getAdmin().flush(tableName);
    Put put = new Put(Bytes.toBytes("row3"));
    put.addColumn(fam, qual, 127L, value);
    put.setCellVisibility(new CellVisibility(CONFIDENTIAL + "&" + PRIVATE));
    table.put(put);
    TEST_UTIL.getAdmin().flush(tableName);
    TEST_UTIL.getAdmin().compact(tableName);
    Thread.sleep(5000);
    // Sleep to ensure compaction happens. Need to do it in a better way
    Scan s = new Scan();
    s.readVersions(5);
    s.setAuthorizations(new Authorizations(SECRET, PRIVATE, CONFIDENTIAL, TOPSECRET));
    ResultScanner scanner = table.getScanner(s);
    Result[] next = scanner.next(3);
    assertTrue(next.length == 3);
    CellScanner cellScanner = next[0].cellScanner();
    cellScanner.advance();
    Cell current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
    assertEquals(127L, current.getTimestamp());
    cellScanner = next[1].cellScanner();
    cellScanner.advance();
    current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row2, 0, row2.length));
  }
}
 

@Test
// test put, delete, increment
public void testWrite() throws Exception {
  // put action
  AccessTestAction putAction = new AccessTestAction() {
    @Override
    public Object run() throws Exception {
      Put p = new Put(TEST_ROW);
      p.addColumn(TEST_FAMILY, TEST_QUALIFIER, Bytes.toBytes(1));
      try(Connection conn = ConnectionFactory.createConnection(conf);
          Table t = conn.getTable(TEST_TABLE)) {
        t.put(p);
      }
      return null;
    }
  };
  verifyWrite(putAction);

  // delete action
  AccessTestAction deleteAction = new AccessTestAction() {
    @Override
    public Object run() throws Exception {
      Delete d = new Delete(TEST_ROW);
      d.addFamily(TEST_FAMILY);
      try(Connection conn = ConnectionFactory.createConnection(conf);
          Table t = conn.getTable(TEST_TABLE)) {
        t.delete(d);
      }
      return null;
    }
  };
  verifyWrite(deleteAction);

  // increment action
  AccessTestAction incrementAction = new AccessTestAction() {
    @Override
    public Object run() throws Exception {
      Increment inc = new Increment(TEST_ROW);
      inc.addColumn(TEST_FAMILY, TEST_QUALIFIER, 1);
      try(Connection conn = ConnectionFactory.createConnection(conf);
          Table t = conn.getTable(TEST_TABLE)) {
        t.increment(inc);
      }
      return null;
    }
  };
  verifyWrite(incrementAction);
}
 

@Test
public void testDeleteFamilySpecificTimeStampWithMulipleVersions() throws Exception {
  setAuths();
  final TableName tableName = TableName.valueOf(testName.getMethodName());
  try (Table table = doPuts(tableName)) {
    TEST_UTIL.getAdmin().flush(tableName);
    PrivilegedExceptionAction<Void> actiona = new PrivilegedExceptionAction<Void>() {
      @Override
      public Void run() throws Exception {
        try (Connection connection = ConnectionFactory.createConnection(conf);
          Table table = connection.getTable(tableName)) {
          Delete d = new Delete(row1);
          d.setCellVisibility(new CellVisibility(
              "(" + PRIVATE + "&" + CONFIDENTIAL + ")|(" + SECRET + "&" + TOPSECRET + ")"));
          d.addFamily(fam, 126L);
          table.delete(d);
        } catch (Throwable t) {
          throw new IOException(t);
        }
        return null;
      }
    };
    SUPERUSER.runAs(actiona);

    TEST_UTIL.getAdmin().flush(tableName);
    Scan s = new Scan();
    s.readVersions(5);
    s.setAuthorizations(new Authorizations(SECRET, PRIVATE, CONFIDENTIAL, TOPSECRET));
    ResultScanner scanner = table.getScanner(s);
    Result[] next = scanner.next(6);
    assertTrue(next.length == 2);
    CellScanner cellScanner = next[0].cellScanner();
    cellScanner.advance();
    Cell current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
    assertEquals(127L, current.getTimestamp());
    cellScanner.advance();
    current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
    assertEquals(125L, current.getTimestamp());
    cellScanner.advance();
    current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row1, 0, row1.length));
    assertEquals(123L, current.getTimestamp());
    cellScanner = next[1].cellScanner();
    cellScanner.advance();
    current = cellScanner.current();
    assertTrue(Bytes.equals(current.getRowArray(), current.getRowOffset(), current.getRowLength(),
      row2, 0, row2.length));
  }
}