public void delete(
final TransactionState transactionState, final Delete delete, final boolean bool_addLocation)
throws IOException {
SingleVersionDeleteNotSupported.validateDelete(delete);
if (bool_addLocation) addLocation(transactionState, super.getRegionLocation(delete.getRow()));
final String regionName =
super.getRegionLocation(delete.getRow()).getRegionInfo().getRegionNameAsString();
Batch.Call<TrxRegionService, DeleteTransactionalResponse> callable =
new Batch.Call<TrxRegionService, DeleteTransactionalResponse>() {
ServerRpcController controller = new ServerRpcController();
BlockingRpcCallback<DeleteTransactionalResponse> rpcCallback =
new BlockingRpcCallback<DeleteTransactionalResponse>();
@Override
public DeleteTransactionalResponse call(TrxRegionService instance) throws IOException {
org.apache.hadoop.hbase.coprocessor.transactional.generated.TrxRegionProtos
.DeleteTransactionalRequest.Builder
builder = DeleteTransactionalRequest.newBuilder();
builder.setTransactionId(transactionState.getTransactionId());
builder.setRegionName(ByteString.copyFromUtf8(regionName));
MutationProto m1 = ProtobufUtil.toMutation(MutationType.DELETE, delete);
builder.setDelete(m1);
instance.delete(controller, builder.build(), rpcCallback);
return rpcCallback.get();
}
};
byte[] row = delete.getRow();
DeleteTransactionalResponse result = null;
try {
int retryCount = 0;
boolean retry = false;
do {
Iterator<Map.Entry<byte[], DeleteTransactionalResponse>> it =
super.coprocessorService(TrxRegionService.class, row, row, callable)
.entrySet()
.iterator();
if (it.hasNext()) {
result = it.next().getValue();
retry = false;
}
if (result == null || result.getException().contains("closing region")) {
Thread.sleep(TransactionalTable.delay);
retry = true;
transactionState.setRetried(true);
retryCount++;
}
} while (retryCount < TransactionalTable.retries && retry == true);
} catch (Throwable t) {
if (LOG.isErrorEnabled()) LOG.error("ERROR while calling delete ", t);
throw new IOException("ERROR while calling coprocessor ", t);
}
if (result == null) throw new IOException(retryErrMsg);
else if (result.hasException()) throw new IOException(result.getException());
}
/**
* Transactional version of {@link HTable#delete(Delete)}
*
* @param transactionState Identifier of the transaction
* @see HTable#delete(Delete)
* @throws IOException
*/
public void delete(TransactionState transactionState, Delete delete) throws IOException {
final long startTimestamp = transactionState.getStartTimestamp();
boolean issueGet = false;
final Put deleteP = new Put(delete.getRow(), startTimestamp);
final Get deleteG = new Get(delete.getRow());
Map<byte[], List<KeyValue>> fmap = delete.getFamilyMap();
if (fmap.isEmpty()) {
issueGet = true;
}
for (List<KeyValue> kvl : fmap.values()) {
for (KeyValue kv : kvl) {
switch (KeyValue.Type.codeToType(kv.getType())) {
case DeleteColumn:
deleteP.add(kv.getFamily(), kv.getQualifier(), startTimestamp, null);
break;
case DeleteFamily:
deleteG.addFamily(kv.getFamily());
issueGet = true;
break;
case Delete:
if (kv.getTimestamp() == HConstants.LATEST_TIMESTAMP) {
deleteP.add(kv.getFamily(), kv.getQualifier(), startTimestamp, null);
break;
} else {
throw new UnsupportedOperationException(
"Cannot delete specific versions on Snapshot Isolation.");
}
}
}
}
if (issueGet) {
Result result = this.get(deleteG);
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();
deleteP.add(family, qualifier, null);
}
}
}
transactionState.addRow(
new RowKeyFamily(delete.getRow(), getTableName(), deleteP.getFamilyMap()));
put(deleteP);
}
@Override
public Object terminatePartial(AggregationBuffer agg) throws HiveException {
DeleteBuffer myagg = (DeleteBuffer) agg;
ArrayList<List<String>> ret = new ArrayList<List<String>>();
ArrayList tname = new ArrayList<String>();
tname.add(configMap.get(HTableFactory.TABLE_NAME_TAG));
tname.add(configMap.get(HTableFactory.ZOOKEEPER_QUORUM_TAG));
for (Map.Entry<String, String> entry : configMap.entrySet()) {
if (!entry.getKey().equals(HTableFactory.TABLE_NAME_TAG)
&& !entry.getKey().equals(HTableFactory.ZOOKEEPER_QUORUM_TAG)) {
tname.add(entry.getKey());
}
}
ret.add(tname);
for (Delete theDelete : myagg.deleteList) {
ArrayList<String> kvList = new ArrayList<String>();
kvList.add(new String(theDelete.getRow()));
ret.add(kvList);
}
return ret;
}
/** @param d Delete to clone. */
public Delete(final Delete d) {
this.row = d.getRow();
this.ts = d.getTimeStamp();
this.familyMap.putAll(d.getFamilyCellMap());
this.durability = d.durability;
for (Map.Entry<String, byte[]> entry : d.getAttributesMap().entrySet()) {
this.setAttribute(entry.getKey(), entry.getValue());
}
}
/** @param d Delete to clone. */
public Delete(final Delete d) {
this.row = d.getRow();
this.ts = d.getTimeStamp();
this.lockId = d.getLockId();
this.familyMap.putAll(d.getFamilyMap());
}
/**
* See safeQueueUpdate(RowMutations mutate)
*
* @param delete Row mutation to perform on the queue
*/
private void safeQueueUpdate(Delete delete) throws ReplicationException, IOException {
RowMutations mutations = new RowMutations(delete.getRow());
mutations.add(delete);
safeQueueUpdate(mutations);
}
/**
* Looking forward to TransactionalRegion-side implementation
*
* @param transactionState
* @param deletes
* @throws IOException
*/
public void delete(final TransactionState transactionState, List<Delete> deletes)
throws IOException {
long transactionId = transactionState.getTransactionId();
if (LOG.isTraceEnabled())
LOG.trace(
"Enter TransactionalTable.delete[] <List> size: "
+ deletes.size()
+ ", transid: "
+ transactionId);
// collect all rows from same region
final Map<TransactionRegionLocation, List<Delete>> rows =
new HashMap<TransactionRegionLocation, List<Delete>>();
HRegionLocation hlocation = null;
TransactionRegionLocation location = null;
List<Delete> list = null;
int size = 0;
for (Delete del : deletes) {
hlocation = this.getRegionLocation(del.getRow(), false);
location =
new TransactionRegionLocation(hlocation.getRegionInfo(), hlocation.getServerName());
if (LOG.isTraceEnabled())
LOG.trace(
"delete <List> with trRegion ["
+ location.getRegionInfo().getEncodedName()
+ "], endKey: "
+ Hex.encodeHexString(location.getRegionInfo().getEndKey())
+ " and transaction ["
+ transactionId
+ "], delete number: "
+ size);
if (!rows.containsKey(location)) {
if (LOG.isTraceEnabled())
LOG.trace(
"delete adding new <List> for region ["
+ location.getRegionInfo().getRegionNameAsString()
+ "], endKey: "
+ Hex.encodeHexString(location.getRegionInfo().getEndKey())
+ " and transaction ["
+ transactionId
+ "], delete number: "
+ size);
list = new ArrayList<Delete>();
rows.put(location, list);
} else {
list = rows.get(location);
}
list.add(del);
size++;
}
final List<Delete> rowsInSameRegion = new ArrayList<Delete>();
for (Map.Entry<TransactionRegionLocation, List<Delete>> entry : rows.entrySet()) {
rowsInSameRegion.clear();
rowsInSameRegion.addAll(entry.getValue());
final String regionName = entry.getKey().getRegionInfo().getRegionNameAsString();
Batch.Call<TrxRegionService, DeleteMultipleTransactionalResponse> callable =
new Batch.Call<TrxRegionService, DeleteMultipleTransactionalResponse>() {
ServerRpcController controller = new ServerRpcController();
BlockingRpcCallback<DeleteMultipleTransactionalResponse> rpcCallback =
new BlockingRpcCallback<DeleteMultipleTransactionalResponse>();
@Override
public DeleteMultipleTransactionalResponse call(TrxRegionService instance)
throws IOException {
org.apache.hadoop.hbase.coprocessor.transactional.generated.TrxRegionProtos
.DeleteMultipleTransactionalRequest.Builder
builder = DeleteMultipleTransactionalRequest.newBuilder();
builder.setTransactionId(transactionState.getTransactionId());
builder.setRegionName(ByteString.copyFromUtf8(regionName));
for (Delete delete : rowsInSameRegion) {
MutationProto m1 = ProtobufUtil.toMutation(MutationType.DELETE, delete);
builder.addDelete(m1);
}
instance.deleteMultiple(controller, builder.build(), rpcCallback);
return rpcCallback.get();
}
};
DeleteMultipleTransactionalResponse result = null;
try {
int retryCount = 0;
boolean retry = false;
do {
Iterator<Map.Entry<byte[], DeleteMultipleTransactionalResponse>> it =
super.coprocessorService(
TrxRegionService.class,
entry.getValue().get(0).getRow(),
entry.getValue().get(0).getRow(),
callable)
.entrySet()
.iterator();
if (it.hasNext()) {
result = it.next().getValue();
retry = false;
}
if (result == null || result.getException().contains("closing region")) {
Thread.sleep(TransactionalTable.delay);
retry = true;
transactionState.setRetried(true);
retryCount++;
}
} while (retryCount < TransactionalTable.retries && retry == true);
} catch (Throwable e) {
if (LOG.isErrorEnabled()) LOG.error("ERROR while calling deleteMultipleTransactional ", e);
throw new IOException("ERROR while calling deleteMultipleTransactional", e);
}
if (result == null) throw new IOException(retryErrMsg);
else if (result.hasException()) throw new IOException(result.getException());
}
}
public boolean checkAndDelete(
final TransactionState transactionState,
final byte[] row,
final byte[] family,
final byte[] qualifier,
final byte[] value,
final Delete delete)
throws IOException {
if (LOG.isTraceEnabled())
LOG.trace(
"Enter TransactionalTable.checkAndDelete row: "
+ row
+ " family: "
+ family
+ " qualifier: "
+ qualifier
+ " value: "
+ value);
if (!Bytes.equals(row, delete.getRow())) {
throw new IOException("Action's getRow must match the passed row");
}
final String regionName =
super.getRegionLocation(delete.getRow()).getRegionInfo().getRegionNameAsString();
if (regionName == null) throw new IOException("Null regionName");
Batch.Call<TrxRegionService, CheckAndDeleteResponse> callable =
new Batch.Call<TrxRegionService, CheckAndDeleteResponse>() {
ServerRpcController controller = new ServerRpcController();
BlockingRpcCallback<CheckAndDeleteResponse> rpcCallback =
new BlockingRpcCallback<CheckAndDeleteResponse>();
@Override
public CheckAndDeleteResponse call(TrxRegionService instance) throws IOException {
org.apache.hadoop.hbase.coprocessor.transactional.generated.TrxRegionProtos
.CheckAndDeleteRequest.Builder
builder = CheckAndDeleteRequest.newBuilder();
builder.setTransactionId(transactionState.getTransactionId());
builder.setRegionName(ByteString.copyFromUtf8(regionName));
builder.setRow(HBaseZeroCopyByteString.wrap(row));
if (family != null) builder.setFamily(HBaseZeroCopyByteString.wrap(family));
else builder.setFamily(HBaseZeroCopyByteString.wrap(new byte[] {}));
if (qualifier != null) builder.setQualifier(HBaseZeroCopyByteString.wrap(qualifier));
else builder.setQualifier(HBaseZeroCopyByteString.wrap(new byte[] {}));
if (value != null) builder.setValue(HBaseZeroCopyByteString.wrap(value));
else builder.setValue(HBaseZeroCopyByteString.wrap(new byte[] {}));
MutationProto m1 = ProtobufUtil.toMutation(MutationType.DELETE, delete);
builder.setDelete(m1);
instance.checkAndDelete(controller, builder.build(), rpcCallback);
return rpcCallback.get();
}
};
CheckAndDeleteResponse result = null;
try {
int retryCount = 0;
boolean retry = false;
do {
Iterator<Map.Entry<byte[], CheckAndDeleteResponse>> it =
super.coprocessorService(
TrxRegionService.class, delete.getRow(), delete.getRow(), callable)
.entrySet()
.iterator();
if (it.hasNext()) {
result = it.next().getValue();
retry = false;
}
if (result == null || result.getException().contains("closing region")) {
Thread.sleep(TransactionalTable.delay);
retry = true;
transactionState.setRetried(true);
retryCount++;
}
} while (retryCount < TransactionalTable.retries && retry == true);
} catch (Throwable e) {
if (LOG.isErrorEnabled()) LOG.error("ERROR while calling checkAndDelete ", e);
throw new IOException("ERROR while calling checkAndDelete ", e);
}
if (result == null) throw new IOException(retryErrMsg);
else if (result.hasException()) throw new IOException(result.getException());
return result.getResult();
}