@Test
public void testAppendHook() throws IOException {
TableName tableName = TableName.valueOf(TEST_TABLE.getNameAsString() + ".testAppendHook");
HTable table = util.createTable(tableName, new byte[][] {A, B, C});
try {
Append app = new Append(Bytes.toBytes(0));
app.add(A, A, A);
verifyMethodResult(
SimpleRegionObserver.class,
new String[] {"hadPreAppend", "hadPostAppend", "hadPreAppendAfterRowLock"},
tableName,
new Boolean[] {false, false, false});
table.append(app);
verifyMethodResult(
SimpleRegionObserver.class,
new String[] {"hadPreAppend", "hadPostAppend", "hadPreAppendAfterRowLock"},
tableName,
new Boolean[] {true, true, true});
} finally {
util.deleteTable(tableName);
table.close();
}
}
/**
* From a {@link TAppend} create an {@link Append}.
*
* @param tappend the Thrift version of an append.
* @return an increment that the {@link TAppend} represented.
*/
public static Append appendFromThrift(TAppend tappend) {
Append append = new Append(tappend.getRow());
List<ByteBuffer> columns = tappend.getColumns();
List<ByteBuffer> values = tappend.getValues();
if (columns.size() != values.size()) {
throw new IllegalArgumentException(
"Sizes of columns and values in tappend object are not matching");
}
int length = columns.size();
for (int i = 0; i < length; i++) {
byte[][] famAndQf = KeyValue.parseColumn(getBytes(columns.get(i)));
append.add(famAndQf[0], famAndQf[1], getBytes(values.get(i)));
}
return append;
}
/**
* Test Append Mutate conversions.
*
* @throws IOException
*/
@Test
public void testAppend() throws IOException {
Mutate.Builder mutateBuilder = Mutate.newBuilder();
mutateBuilder.setRow(ByteString.copyFromUtf8("row"));
mutateBuilder.setMutateType(MutateType.APPEND);
mutateBuilder.setTimestamp(111111);
ColumnValue.Builder valueBuilder = ColumnValue.newBuilder();
valueBuilder.setFamily(ByteString.copyFromUtf8("f1"));
QualifierValue.Builder qualifierBuilder = QualifierValue.newBuilder();
qualifierBuilder.setQualifier(ByteString.copyFromUtf8("c1"));
qualifierBuilder.setValue(ByteString.copyFromUtf8("v1"));
valueBuilder.addQualifierValue(qualifierBuilder.build());
qualifierBuilder.setQualifier(ByteString.copyFromUtf8("c2"));
qualifierBuilder.setValue(ByteString.copyFromUtf8("v2"));
valueBuilder.addQualifierValue(qualifierBuilder.build());
mutateBuilder.addColumnValue(valueBuilder.build());
Mutate proto = mutateBuilder.build();
// default fields
assertEquals(true, proto.getWriteToWAL());
// set the default value for equal comparison
mutateBuilder = Mutate.newBuilder(proto);
mutateBuilder.setWriteToWAL(true);
Append append = ProtobufUtil.toAppend(proto);
// append always use the latest timestamp,
// add the timestamp to the original mutate
long timestamp = append.getTimeStamp();
mutateBuilder.setTimestamp(timestamp);
for (ColumnValue.Builder column : mutateBuilder.getColumnValueBuilderList()) {
for (QualifierValue.Builder qualifier : column.getQualifierValueBuilderList()) {
qualifier.setTimestamp(timestamp);
}
}
assertEquals(mutateBuilder.build(), ProtobufUtil.toMutate(MutateType.APPEND, append));
}
/**
* Override the preAppend for checkAndPut and checkAndDelete, as we need the ability to a) set the
* TimeRange for the Get being done and b) return something back to the client to indicate
* success/failure
*/
@SuppressWarnings("deprecation")
@Override
public Result preAppend(
final ObserverContext<RegionCoprocessorEnvironment> e, final Append append)
throws IOException {
byte[] opBuf = append.getAttribute(OPERATION_ATTRIB);
if (opBuf == null) {
return null;
}
Op op = Op.values()[opBuf[0]];
long clientTimestamp = HConstants.LATEST_TIMESTAMP;
byte[] clientTimestampBuf = append.getAttribute(MAX_TIMERANGE_ATTRIB);
if (clientTimestampBuf != null) {
clientTimestamp = Bytes.toLong(clientTimestampBuf);
}
boolean hadClientTimestamp = (clientTimestamp != HConstants.LATEST_TIMESTAMP);
if (hadClientTimestamp) {
// Prevent race condition of creating two sequences at the same timestamp
// by looking for a sequence at or after the timestamp at which it'll be
// created.
if (op == Op.CREATE_SEQUENCE) {
clientTimestamp++;
}
} else {
clientTimestamp = EnvironmentEdgeManager.currentTimeMillis();
clientTimestampBuf = Bytes.toBytes(clientTimestamp);
}
RegionCoprocessorEnvironment env = e.getEnvironment();
// We need to set this to prevent region.append from being called
e.bypass();
e.complete();
HRegion region = env.getRegion();
byte[] row = append.getRow();
region.startRegionOperation();
try {
Integer lid = region.getLock(null, row, true);
try {
KeyValue keyValue = append.getFamilyMap().values().iterator().next().iterator().next();
byte[] family = keyValue.getFamily();
byte[] qualifier = keyValue.getQualifier();
Get get = new Get(row);
get.setTimeRange(MetaDataProtocol.MIN_TABLE_TIMESTAMP, clientTimestamp);
get.addColumn(family, qualifier);
Result result = region.get(get);
if (result.isEmpty()) {
if (op == Op.DROP_SEQUENCE || op == Op.RESET_SEQUENCE) {
return getErrorResult(
row, clientTimestamp, SQLExceptionCode.SEQUENCE_UNDEFINED.getErrorCode());
}
} else {
if (op == Op.CREATE_SEQUENCE) {
return getErrorResult(
row, clientTimestamp, SQLExceptionCode.SEQUENCE_ALREADY_EXIST.getErrorCode());
}
}
Mutation m = null;
switch (op) {
case RESET_SEQUENCE:
KeyValue currentValueKV = result.raw()[0];
long expectedValue =
PDataType.LONG
.getCodec()
.decodeLong(append.getAttribute(CURRENT_VALUE_ATTRIB), 0, null);
long value =
PDataType.LONG
.getCodec()
.decodeLong(currentValueKV.getBuffer(), currentValueKV.getValueOffset(), null);
// Timestamp should match exactly, or we may have the wrong sequence
if (expectedValue != value || currentValueKV.getTimestamp() != clientTimestamp) {
return new Result(
Collections.singletonList(
KeyValueUtil.newKeyValue(
row,
PhoenixDatabaseMetaData.SEQUENCE_FAMILY_BYTES,
QueryConstants.EMPTY_COLUMN_BYTES,
currentValueKV.getTimestamp(),
ByteUtil.EMPTY_BYTE_ARRAY)));
}
m = new Put(row, currentValueKV.getTimestamp());
m.getFamilyMap().putAll(append.getFamilyMap());
break;
case DROP_SEQUENCE:
m = new Delete(row, clientTimestamp, null);
break;
case CREATE_SEQUENCE:
m = new Put(row, clientTimestamp);
m.getFamilyMap().putAll(append.getFamilyMap());
break;
}
if (!hadClientTimestamp) {
for (List<KeyValue> kvs : m.getFamilyMap().values()) {
for (KeyValue kv : kvs) {
kv.updateLatestStamp(clientTimestampBuf);
}
}
}
@SuppressWarnings("unchecked")
Pair<Mutation, Integer>[] mutations = new Pair[1];
mutations[0] = new Pair<Mutation, Integer>(m, lid);
region.batchMutate(mutations);
long serverTimestamp = MetaDataUtil.getClientTimeStamp(m);
// Return result with single KeyValue. The only piece of information
// the client cares about is the timestamp, which is the timestamp of
// when the mutation was actually performed (useful in the case of .
return new Result(
Collections.singletonList(
KeyValueUtil.newKeyValue(
row,
PhoenixDatabaseMetaData.SEQUENCE_FAMILY_BYTES,
QueryConstants.EMPTY_COLUMN_BYTES,
serverTimestamp,
SUCCESS_VALUE)));
} finally {
region.releaseRowLock(lid);
}
} catch (Throwable t) {
ServerUtil.throwIOException("Increment of sequence " + Bytes.toStringBinary(row), t);
return null; // Impossible
} finally {
region.closeRegionOperation();
}
}