From f771fd26b44929623ee31c866544cbc26dad3ffe Mon Sep 17 00:00:00 2001 From: Toshihiro Suzuki Date: Wed, 8 Jul 2020 08:00:48 +0900 Subject: [PATCH] HBASE-24650 Change the return types of the new checkAndMutate methods introduced in HBASE-8458 (#2033) Signed-off-by: Duo Zhang --- .../hadoop/hbase/client/AsyncTable.java | 9 +- .../hadoop/hbase/client/AsyncTableImpl.java | 5 +- .../hbase/client/CheckAndMutateResult.java | 48 ++++++ .../apache/hadoop/hbase/client/HTable.java | 77 ++++----- .../hbase/client/RawAsyncTableImpl.java | 53 +++--- .../org/apache/hadoop/hbase/client/Table.java | 12 +- .../shaded/protobuf/ResponseConverter.java | 74 +++++++-- .../hbase/rest/client/RemoteHTable.java | 6 +- .../hadoop/hbase/client/TestAsyncTable.java | 154 +++++++++--------- .../hbase/client/TestAsyncTableBatch.java | 4 +- .../hbase/client/TestCheckAndMutate.java | 129 ++++++++------- .../hbase/client/TestFromClientSide3.java | 4 +- .../hbase/thrift2/client/ThriftTable.java | 5 +- 13 files changed, 342 insertions(+), 238 deletions(-) create mode 100644 hbase-client/src/main/java/org/apache/hadoop/hbase/client/CheckAndMutateResult.java diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTable.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTable.java index fd10603fa8d..25ea143c970 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTable.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTable.java @@ -367,7 +367,7 @@ public interface AsyncTable { * @param checkAndMutate The CheckAndMutate object. * @return A {@link CompletableFuture}s that represent the result for the CheckAndMutate. */ - CompletableFuture checkAndMutate(CheckAndMutate checkAndMutate); + CompletableFuture checkAndMutate(CheckAndMutate checkAndMutate); /** * Batch version of checkAndMutate. The specified CheckAndMutates are batched only in the sense @@ -378,15 +378,16 @@ public interface AsyncTable { * @return A list of {@link CompletableFuture}s that represent the result for each * CheckAndMutate. */ - List> checkAndMutate(List checkAndMutates); + List> checkAndMutate( + List checkAndMutates); /** * A simple version of batch checkAndMutate. It will fail if there are any failures. * * @param checkAndMutates The list of rows to apply. - * @return A {@link CompletableFuture} that wrapper the result boolean list. + * @return A {@link CompletableFuture} that wrapper the result list. */ - default CompletableFuture> checkAndMutateAll( + default CompletableFuture> checkAndMutateAll( List checkAndMutates) { return allOf(checkAndMutate(checkAndMutates)); } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableImpl.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableImpl.java index 836c9b52e11..82e8cd5b57a 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableImpl.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncTableImpl.java @@ -205,12 +205,13 @@ class AsyncTableImpl implements AsyncTable { } @Override - public CompletableFuture checkAndMutate(CheckAndMutate checkAndMutate) { + public CompletableFuture checkAndMutate(CheckAndMutate checkAndMutate) { return wrap(rawTable.checkAndMutate(checkAndMutate)); } @Override - public List> checkAndMutate(List checkAndMutates) { + public List> checkAndMutate( + List checkAndMutates) { return rawTable.checkAndMutate(checkAndMutates).stream() .map(this::wrap).collect(toList()); } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/CheckAndMutateResult.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/CheckAndMutateResult.java new file mode 100644 index 00000000000..88b438a74a0 --- /dev/null +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/CheckAndMutateResult.java @@ -0,0 +1,48 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.hadoop.hbase.client; + +import org.apache.yetus.audience.InterfaceAudience; + +/** + * Represents a result of a CheckAndMutate operation + */ +@InterfaceAudience.Public +public class CheckAndMutateResult { + private final boolean success; + private final Result result; + + public CheckAndMutateResult(boolean success, Result result) { + this.success = success; + this.result = result; + } + + /** + * @return Whether the CheckAndMutate operation is successful or not + */ + public boolean isSuccess() { + return success; + } + + /** + * @return It is used only for CheckAndMutate operations with Increment/Append. Otherwise null + */ + public Result getResult() { + return result; + } +} diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java index 5f02260036d..51e45b17fa2 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java @@ -676,7 +676,7 @@ public class HTable implements Table { public boolean checkAndPut(final byte [] row, final byte [] family, final byte [] qualifier, final byte [] value, final Put put) throws IOException { return doCheckAndPut(row, family, qualifier, CompareOperator.EQUAL, value, null, null, - put); + put).isSuccess(); } @Override @@ -684,7 +684,7 @@ public class HTable implements Table { public boolean checkAndPut(final byte [] row, final byte [] family, final byte [] qualifier, final CompareOp compareOp, final byte [] value, final Put put) throws IOException { return doCheckAndPut(row, family, qualifier, toCompareOperator(compareOp), value, null, - null, put); + null, put).isSuccess(); } @Override @@ -693,25 +693,25 @@ public class HTable implements Table { final CompareOperator op, final byte [] value, final Put put) throws IOException { // The name of the operators in CompareOperator are intentionally those of the // operators in the filter's CompareOp enum. - return doCheckAndPut(row, family, qualifier, op, value, null, null, put); + return doCheckAndPut(row, family, qualifier, op, value, null, null, put).isSuccess(); } - private boolean doCheckAndPut(final byte[] row, final byte[] family, final byte[] qualifier, - final CompareOperator op, final byte[] value, final Filter filter, final TimeRange timeRange, - final Put put) throws IOException { - ClientServiceCallable callable = - new ClientServiceCallable(this.connection, getName(), row, + private CheckAndMutateResult doCheckAndPut(final byte[] row, final byte[] family, + final byte[] qualifier, final CompareOperator op, final byte[] value, final Filter filter, + final TimeRange timeRange, final Put put) throws IOException { + ClientServiceCallable callable = + new ClientServiceCallable(this.connection, getName(), row, this.rpcControllerFactory.newController(), put.getPriority()) { @Override - protected Boolean rpcCall() throws Exception { + protected CheckAndMutateResult rpcCall() throws Exception { MutateRequest request = RequestConverter.buildMutateRequest( getLocation().getRegionInfo().getRegionName(), row, family, qualifier, op, value, filter, timeRange, put); MutateResponse response = doMutate(request); - return Boolean.valueOf(response.getProcessed()); + return new CheckAndMutateResult(response.getProcessed(), null); } }; - return rpcCallerFactory. newCaller(this.writeRpcTimeoutMs) + return rpcCallerFactory. newCaller(this.writeRpcTimeoutMs) .callWithRetries(callable, this.operationTimeoutMs); } @@ -720,7 +720,7 @@ public class HTable implements Table { public boolean checkAndDelete(final byte[] row, final byte[] family, final byte[] qualifier, final byte[] value, final Delete delete) throws IOException { return doCheckAndDelete(row, family, qualifier, CompareOperator.EQUAL, value, null, - null, delete); + null, delete).isSuccess(); } @Override @@ -728,19 +728,19 @@ public class HTable implements Table { public boolean checkAndDelete(final byte[] row, final byte[] family, final byte[] qualifier, final CompareOp compareOp, final byte[] value, final Delete delete) throws IOException { return doCheckAndDelete(row, family, qualifier, toCompareOperator(compareOp), value, null, - null, delete); + null, delete).isSuccess(); } @Override @Deprecated public boolean checkAndDelete(final byte[] row, final byte[] family, final byte[] qualifier, final CompareOperator op, final byte[] value, final Delete delete) throws IOException { - return doCheckAndDelete(row, family, qualifier, op, value, null, null, delete); + return doCheckAndDelete(row, family, qualifier, op, value, null, null, delete).isSuccess(); } - private boolean doCheckAndDelete(final byte[] row, final byte[] family, final byte[] qualifier, - final CompareOperator op, final byte[] value, final Filter filter, final TimeRange timeRange, - final Delete delete) throws IOException { + private CheckAndMutateResult doCheckAndDelete(final byte[] row, final byte[] family, + final byte[] qualifier, final CompareOperator op, final byte[] value, final Filter filter, + final TimeRange timeRange, final Delete delete) throws IOException { CancellableRegionServerCallable callable = new CancellableRegionServerCallable(this.connection, getName(), row, this.rpcControllerFactory.newController(), writeRpcTimeoutMs, @@ -768,7 +768,7 @@ public class HTable implements Table { if (ars.hasError()) { throw ars.getErrors(); } - return ((SingleResponse.Entry) results[0]).isProcessed(); + return new CheckAndMutateResult(((SingleResponse.Entry) results[0]).isProcessed(), null); } @Override @@ -783,10 +783,9 @@ public class HTable implements Table { return new CheckAndMutateWithFilterBuilderImpl(row, filter); } - private boolean doCheckAndMutate(final byte[] row, final byte[] family, final byte[] qualifier, - final CompareOperator op, final byte[] value, final Filter filter, final TimeRange timeRange, - final RowMutations rm) - throws IOException { + private CheckAndMutateResult doCheckAndMutate(final byte[] row, final byte[] family, + final byte[] qualifier, final CompareOperator op, final byte[] value, final Filter filter, + final TimeRange timeRange, final RowMutations rm) throws IOException { CancellableRegionServerCallable callable = new CancellableRegionServerCallable(connection, getName(), rm.getRow(), rpcControllerFactory.newController(), writeRpcTimeoutMs, new RetryingTimeTracker().start(), @@ -832,7 +831,7 @@ public class HTable implements Table { throw ars.getErrors(); } - return ((Result)results[0]).getExists(); + return (CheckAndMutateResult) results[0]; } @Override @@ -841,18 +840,18 @@ public class HTable implements Table { final CompareOp compareOp, final byte [] value, final RowMutations rm) throws IOException { return doCheckAndMutate(row, family, qualifier, toCompareOperator(compareOp), value, null, - null, rm); + null, rm).isSuccess(); } @Override @Deprecated public boolean checkAndMutate(final byte [] row, final byte [] family, final byte [] qualifier, final CompareOperator op, final byte [] value, final RowMutations rm) throws IOException { - return doCheckAndMutate(row, family, qualifier, op, value, null, null, rm); + return doCheckAndMutate(row, family, qualifier, op, value, null, null, rm).isSuccess(); } @Override - public boolean checkAndMutate(CheckAndMutate checkAndMutate) throws IOException { + public CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate) throws IOException { Row action = checkAndMutate.getAction(); if (action instanceof Put) { Put put = (Put) action; @@ -872,12 +871,13 @@ public class HTable implements Table { } @Override - public boolean[] checkAndMutate(List checkAndMutates) throws IOException { + public List checkAndMutate(List checkAndMutates) + throws IOException { if (checkAndMutates.isEmpty()) { - return new boolean[]{}; + return Collections.emptyList(); } if (checkAndMutates.size() == 1) { - return new boolean[]{ checkAndMutate(checkAndMutates.get(0)) }; + return Collections.singletonList(checkAndMutate(checkAndMutates.get(0))); } Object[] results = new Object[checkAndMutates.size()]; @@ -888,11 +888,10 @@ public class HTable implements Table { } // translate. - boolean[] ret = new boolean[results.length]; - int i = 0; + List ret = new ArrayList<>(results.length); for (Object r : results) { // Batch ensures if there is a failure we get an exception instead - ret[i++] = ((Result) r).getExists(); + ret.add((CheckAndMutateResult) r); } return ret; } @@ -1329,20 +1328,21 @@ public class HTable implements Table { public boolean thenPut(Put put) throws IOException { validatePut(put); preCheck(); - return doCheckAndPut(row, family, qualifier, op, value, null, timeRange, put); + return doCheckAndPut(row, family, qualifier, op, value, null, timeRange, put).isSuccess(); } @Override public boolean thenDelete(Delete delete) throws IOException { preCheck(); - return doCheckAndDelete(row, family, qualifier, op, value, null, timeRange, delete); + return doCheckAndDelete(row, family, qualifier, op, value, null, timeRange, delete) + .isSuccess(); } @Override public boolean thenMutate(RowMutations mutation) throws IOException { preCheck(); return doCheckAndMutate(row, family, qualifier, op, value, null, timeRange, - mutation); + mutation).isSuccess(); } } @@ -1366,17 +1366,18 @@ public class HTable implements Table { @Override public boolean thenPut(Put put) throws IOException { validatePut(put); - return doCheckAndPut(row, null, null, null, null, filter, timeRange, put); + return doCheckAndPut(row, null, null, null, null, filter, timeRange, put).isSuccess(); } @Override public boolean thenDelete(Delete delete) throws IOException { - return doCheckAndDelete(row, null, null, null, null, filter, timeRange, delete); + return doCheckAndDelete(row, null, null, null, null, filter, timeRange, delete).isSuccess(); } @Override public boolean thenMutate(RowMutations mutation) throws IOException { - return doCheckAndMutate(row, null, null, null, null, filter, timeRange, mutation); + return doCheckAndMutate(row, null, null, null, null, filter, timeRange, mutation) + .isSuccess(); } } } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/RawAsyncTableImpl.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/RawAsyncTableImpl.java index dc3e530cceb..aa42838b26a 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/RawAsyncTableImpl.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/RawAsyncTableImpl.java @@ -386,8 +386,7 @@ class RawAsyncTableImpl implements AsyncTable { .action((controller, loc, stub) -> RawAsyncTableImpl.this.mutateRow(controller, loc, stub, mutation, (rn, rm) -> RequestConverter.buildMutateRequest(rn, row, family, qualifier, op, value, - null, timeRange, rm), - resp -> resp.getExists())) + null, timeRange, rm), CheckAndMutateResult::isSuccess)) .call(); } } @@ -447,8 +446,7 @@ class RawAsyncTableImpl implements AsyncTable { .action((controller, loc, stub) -> RawAsyncTableImpl.this.mutateRow(controller, loc, stub, mutation, (rn, rm) -> RequestConverter.buildMutateRequest(rn, row, null, null, null, null, - filter, timeRange, rm), - resp -> resp.getExists())) + filter, timeRange, rm), CheckAndMutateResult::isSuccess)) .call(); } } @@ -459,7 +457,7 @@ class RawAsyncTableImpl implements AsyncTable { } @Override - public CompletableFuture checkAndMutate(CheckAndMutate checkAndMutate) { + public CompletableFuture checkAndMutate(CheckAndMutate checkAndMutate) { if (checkAndMutate.getAction() instanceof Put) { validatePut((Put) checkAndMutate.getAction(), conn.connConf.getMaxKeyValueSize()); } @@ -469,7 +467,7 @@ class RawAsyncTableImpl implements AsyncTable { if (mutation instanceof Put) { validatePut((Put) mutation, conn.connConf.getMaxKeyValueSize()); } - return RawAsyncTableImpl.this. newCaller(checkAndMutate.getRow(), + return RawAsyncTableImpl.this. newCaller(checkAndMutate.getRow(), mutation.getPriority(), rpcTimeoutNs) .action((controller, loc, stub) -> RawAsyncTableImpl.mutate(controller, loc, stub, mutation, @@ -477,22 +475,23 @@ class RawAsyncTableImpl implements AsyncTable { checkAndMutate.getFamily(), checkAndMutate.getQualifier(), checkAndMutate.getCompareOp(), checkAndMutate.getValue(), checkAndMutate.getFilter(), checkAndMutate.getTimeRange(), m), - (c, r) -> r.getProcessed())) + (c, r) -> ResponseConverter.getCheckAndMutateResult(r))) .call(); } else if (checkAndMutate.getAction() instanceof RowMutations) { RowMutations rowMutations = (RowMutations) checkAndMutate.getAction(); - return RawAsyncTableImpl.this. newCaller(checkAndMutate.getRow(), + return RawAsyncTableImpl.this. newCaller(checkAndMutate.getRow(), rowMutations.getMaxPriority(), rpcTimeoutNs) - .action((controller, loc, stub) -> RawAsyncTableImpl.this.mutateRow(controller, - loc, stub, rowMutations, - (rn, rm) -> RequestConverter.buildMutateRequest(rn, checkAndMutate.getRow(), + .action((controller, loc, stub) -> + RawAsyncTableImpl.this. mutateRow( + controller, loc, stub, rowMutations, + (rn, rm) -> RequestConverter.buildMutateRequest(rn, checkAndMutate.getRow(), checkAndMutate.getFamily(), checkAndMutate.getQualifier(), checkAndMutate.getCompareOp(), checkAndMutate.getValue(), checkAndMutate.getFilter(), checkAndMutate.getTimeRange(), rm), - resp -> resp.getExists())) + resp -> resp)) .call(); } else { - CompletableFuture future = new CompletableFuture<>(); + CompletableFuture future = new CompletableFuture<>(); future.completeExceptionally(new DoNotRetryIOException( "CheckAndMutate doesn't support " + checkAndMutate.getAction().getClass().getName())); return future; @@ -500,18 +499,19 @@ class RawAsyncTableImpl implements AsyncTable { } @Override - public List> checkAndMutate(List checkAndMutates) { + public List> checkAndMutate( + List checkAndMutates) { return batch(checkAndMutates, rpcTimeoutNs).stream() - .map(f -> f.thenApply(r -> ((Result)r).getExists())) - .collect(toList()); + .map(f -> f.thenApply(r -> (CheckAndMutateResult) r)).collect(toList()); } // We need the MultiRequest when constructing the org.apache.hadoop.hbase.client.MultiResponse, // so here I write a new method as I do not want to change the abstraction of call method. - private CompletableFuture mutateRow(HBaseRpcController controller, + @SuppressWarnings("unchecked") + private CompletableFuture mutateRow(HBaseRpcController controller, HRegionLocation loc, ClientService.Interface stub, RowMutations mutation, Converter reqConvert, - Function respConverter) { + Function respConverter) { CompletableFuture future = new CompletableFuture<>(); try { byte[] regionName = loc.getRegion().getRegionName(); @@ -535,7 +535,7 @@ class RawAsyncTableImpl implements AsyncTable { "Failed to mutate row: " + Bytes.toStringBinary(mutation.getRow()), ex)); } else { future.complete(respConverter - .apply((Result) multiResp.getResults().get(regionName).result.get(0))); + .apply((RES) multiResp.getResults().get(regionName).result.get(0))); } } catch (IOException e) { future.completeExceptionally(e); @@ -552,12 +552,15 @@ class RawAsyncTableImpl implements AsyncTable { @Override public CompletableFuture mutateRow(RowMutations mutation) { return this. newCaller(mutation.getRow(), mutation.getMaxPriority(), writeRpcTimeoutNs) - .action((controller, loc, stub) -> this. mutateRow(controller, loc, stub, mutation, - (rn, rm) -> { - RegionAction.Builder regionMutationBuilder = RequestConverter.buildRegionAction(rn, rm); - regionMutationBuilder.setAtomic(true); - return MultiRequest.newBuilder().addRegionAction(regionMutationBuilder.build()).build(); - }, resp -> null)) + .action((controller, loc, stub) -> + this. mutateRow(controller, loc, stub, mutation, + (rn, rm) -> { + RegionAction.Builder regionMutationBuilder = RequestConverter + .buildRegionAction(rn, rm); + regionMutationBuilder.setAtomic(true); + return MultiRequest.newBuilder().addRegionAction(regionMutationBuilder.build()) + .build(); + }, resp -> null)) .call(); } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java index b21998029d3..34f5e39a4ff 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Table.java @@ -617,11 +617,11 @@ public interface Table extends Closeable { * it performs the specified action. * * @param checkAndMutate The CheckAndMutate object. - * @return boolean that represents the result for the CheckAndMutate. + * @return A CheckAndMutateResult object that represents the result for the CheckAndMutate. * @throws IOException if a remote or network exception occurs. */ - default boolean checkAndMutate(CheckAndMutate checkAndMutate) throws IOException { - return checkAndMutate(Collections.singletonList(checkAndMutate))[0]; + default CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate) throws IOException { + return checkAndMutate(Collections.singletonList(checkAndMutate)).get(0); } /** @@ -630,10 +630,12 @@ public interface Table extends Closeable { * atomically (and thus, each may fail independently of others). * * @param checkAndMutates The list of CheckAndMutate. - * @return A array of boolean that represents the result for each CheckAndMutate. + * @return A list of CheckAndMutateResult objects that represents the result for each + * CheckAndMutate. * @throws IOException if a remote or network exception occurs. */ - default boolean[] checkAndMutate(List checkAndMutates) throws IOException { + default List checkAndMutate(List checkAndMutates) + throws IOException { throw new NotImplementedException("Add an implementation!"); } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ResponseConverter.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ResponseConverter.java index b414b7b6dbb..ffe39702edd 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ResponseConverter.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ResponseConverter.java @@ -27,6 +27,7 @@ import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellScanner; import org.apache.hadoop.hbase.DoNotRetryIOException; import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.client.CheckAndMutateResult; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.SingleResponse; @@ -156,29 +157,55 @@ public final class ResponseConverter { // This RegionAction is from a RowMutations/CheckAndMutate in a batch. // If there is an exception from the server, the exception is set at // the RegionActionResult level, which has been handled above. - responseValue = actionResult.getProcessed() ? + if (actions.hasCondition()) { + Result result = null; + if (actionResult.getResultOrExceptionCount() > 0) { + ResultOrException roe = actionResult.getResultOrException(0); + if (roe.hasResult()) { + Result r = ProtobufUtil.toResult(roe.getResult(), cells); + if (!r.isEmpty()) { + result = r; + } + } + } + responseValue = new CheckAndMutateResult(actionResult.getProcessed(), result); + } else { + responseValue = actionResult.getProcessed() ? ProtobufUtil.EMPTY_RESULT_EXISTS_TRUE : ProtobufUtil.EMPTY_RESULT_EXISTS_FALSE; + } results.add(regionName, index, responseValue); continue; } - for (ResultOrException roe : actionResult.getResultOrExceptionList()) { - if (roe.hasException()) { - responseValue = ProtobufUtil.toException(roe.getException()); - } else if (roe.hasResult()) { - responseValue = ProtobufUtil.toResult(roe.getResult(), cells); - } else if (roe.hasServiceResult()) { - responseValue = roe.getServiceResult(); - } else { - // Sometimes, the response is just "it was processed". Generally, this occurs for things - // like mutateRows where either we get back 'processed' (or not) and optionally some - // statistics about the regions we touched. - responseValue = actionResult.getProcessed() ? - ProtobufUtil.EMPTY_RESULT_EXISTS_TRUE : - ProtobufUtil.EMPTY_RESULT_EXISTS_FALSE; + if (actions.hasCondition()) { + for (ResultOrException roe : actionResult.getResultOrExceptionList()) { + Result result = null; + Result r = ProtobufUtil.toResult(roe.getResult(), cells); + if (!r.isEmpty()) { + result = r; + } + responseValue = new CheckAndMutateResult(actionResult.getProcessed(), result); + results.add(regionName, roe.getIndex(), responseValue); + } + } else { + for (ResultOrException roe : actionResult.getResultOrExceptionList()) { + if (roe.hasException()) { + responseValue = ProtobufUtil.toException(roe.getException()); + } else if (roe.hasResult()) { + responseValue = ProtobufUtil.toResult(roe.getResult(), cells); + } else if (roe.hasServiceResult()) { + responseValue = roe.getServiceResult(); + } else { + // Sometimes, the response is just "it was processed". Generally, this occurs for things + // like mutateRows where either we get back 'processed' (or not) and optionally some + // statistics about the regions we touched. + responseValue = actionResult.getProcessed() ? + ProtobufUtil.EMPTY_RESULT_EXISTS_TRUE : + ProtobufUtil.EMPTY_RESULT_EXISTS_FALSE; + } + results.add(regionName, roe.getIndex(), responseValue); } - results.add(regionName, roe.getIndex(), responseValue); } } @@ -192,6 +219,21 @@ public final class ResponseConverter { return results; } + /** + * Create a CheckAndMutateResult object from a protocol buffer MutateResponse + * + * @return a CheckAndMutateResult object + */ + public static CheckAndMutateResult getCheckAndMutateResult( + ClientProtos.MutateResponse mutateResponse) { + boolean success = mutateResponse.getProcessed(); + Result result = null; + if (mutateResponse.hasResult()) { + result = ProtobufUtil.toResult(mutateResponse.getResult()); + } + return new CheckAndMutateResult(success, result); + } + /** * Wrap a throwable to an action result. * diff --git a/hbase-rest/src/test/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java b/hbase-rest/src/test/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java index cd9ec7fc269..f849601a68b 100644 --- a/hbase-rest/src/test/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java +++ b/hbase-rest/src/test/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java @@ -53,6 +53,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.client.Append; import org.apache.hadoop.hbase.client.CheckAndMutate; +import org.apache.hadoop.hbase.client.CheckAndMutateResult; import org.apache.hadoop.hbase.client.Delete; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Increment; @@ -812,13 +813,12 @@ public class RemoteHTable implements Table { throw new UnsupportedOperationException("checkAndMutate not implemented"); } - @Override - public boolean checkAndMutate(CheckAndMutate checkAndMutate) { + public CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate) { throw new NotImplementedException("Implement later"); } @Override - public boolean[] checkAndMutate(List checkAndMutates) { + public List checkAndMutate(List checkAndMutates) { throw new NotImplementedException("Implement later"); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncTable.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncTable.java index 0de18929d7c..de81750574f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncTable.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncTable.java @@ -632,7 +632,7 @@ public class TestAsyncTable { .ifNotExists(FAMILY, QUALIFIER) .build(new Put(row).addColumn(FAMILY, QUALIFIER, concat(VALUE, i)))) .thenAccept(x -> { - if (x) { + if (x.isSuccess()) { successCount.incrementAndGet(); successIndex.set(i); } @@ -666,7 +666,7 @@ public class TestAsyncTable { .build( new Delete(row).addColumn(FAMILY, QUALIFIER).addColumn(FAMILY, concat(QUALIFIER, i)))) .thenAccept(x -> { - if (x) { + if (x.isSuccess()) { successCount.incrementAndGet(); successIndex.set(i); } @@ -713,7 +713,7 @@ public class TestAsyncTable { .ifEquals(FAMILY, QUALIFIER, VALUE) .build(mutation)) .thenAccept(x -> { - if (x) { + if (x.isSuccess()) { successCount.incrementAndGet(); successIndex.set(i); } @@ -739,50 +739,50 @@ public class TestAsyncTable { Put put = new Put(row); put.addColumn(FAMILY, QUALIFIER, ts, VALUE); - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifNotExists(FAMILY, QUALIFIER) .build(put)).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifEquals(FAMILY, QUALIFIER, VALUE) .timeRange(TimeRange.at(ts + 10000)) .build(put)).get(); - assertFalse(ok); + assertFalse(result.isSuccess()); - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifEquals(FAMILY, QUALIFIER, VALUE) .timeRange(TimeRange.at(ts)) .build(put)).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); RowMutations rm = new RowMutations(row).add((Mutation) put); - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifEquals(FAMILY, QUALIFIER, VALUE) .timeRange(TimeRange.at(ts + 10000)) .build(rm)).get(); - assertFalse(ok); + assertFalse(result.isSuccess()); - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifEquals(FAMILY, QUALIFIER, VALUE) .timeRange(TimeRange.at(ts)) .build(rm)).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); Delete delete = new Delete(row).addColumn(FAMILY, QUALIFIER); - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifEquals(FAMILY, QUALIFIER, VALUE) .timeRange(TimeRange.at(ts + 10000)) .build(delete)).get(); - assertFalse(ok); + assertFalse(result.isSuccess()); - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifEquals(FAMILY, QUALIFIER, VALUE) .timeRange(TimeRange.at(ts)) .build(delete)).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); } @Test @@ -797,45 +797,45 @@ public class TestAsyncTable { table.put(put).get(); // Put with success - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a"))) .build(new Put(row).addColumn(FAMILY, Bytes.toBytes("D"), Bytes.toBytes("d")))).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); - Result result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get(); - assertEquals("d", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("D")))); + Result r = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get(); + assertEquals("d", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("D")))); // Put with failure - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("b"))) .build(new Put(row).addColumn(FAMILY, Bytes.toBytes("E"), Bytes.toBytes("e")))).get(); - assertFalse(ok); + assertFalse(result.isSuccess()); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("E"))).get()); // Delete with success - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a"))) .build(new Delete(row).addColumns(FAMILY, Bytes.toBytes("D")))).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get()); // Mutate with success - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("B"), CompareOperator.EQUAL, Bytes.toBytes("b"))) .build(new RowMutations(row) .add((Mutation) new Put(row) .addColumn(FAMILY, Bytes.toBytes("D"), Bytes.toBytes("d"))) .add((Mutation) new Delete(row).addColumns(FAMILY, Bytes.toBytes("A"))))).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); - result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get(); - assertEquals("d", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("D")))); + r = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get(); + assertEquals("d", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("D")))); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("A"))).get()); } @@ -852,44 +852,44 @@ public class TestAsyncTable { table.put(put).get(); // Put with success - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new FilterList( new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a")), new SingleColumnValueFilter(FAMILY, Bytes.toBytes("B"), CompareOperator.EQUAL, Bytes.toBytes("b")))) .build(new Put(row).addColumn(FAMILY, Bytes.toBytes("D"), Bytes.toBytes("d")))).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); - Result result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get(); - assertEquals("d", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("D")))); + Result r = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get(); + assertEquals("d", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("D")))); // Put with failure - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new FilterList( new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a")), new SingleColumnValueFilter(FAMILY, Bytes.toBytes("B"), CompareOperator.EQUAL, Bytes.toBytes("c")))) .build(new Put(row).addColumn(FAMILY, Bytes.toBytes("E"), Bytes.toBytes("e")))).get(); - assertFalse(ok); + assertFalse(result.isSuccess()); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("E"))).get()); // Delete with success - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new FilterList( new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a")), new SingleColumnValueFilter(FAMILY, Bytes.toBytes("B"), CompareOperator.EQUAL, Bytes.toBytes("b")))) .build(new Delete(row).addColumns(FAMILY, Bytes.toBytes("D")))).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get()); // Mutate with success - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new FilterList( new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a")), @@ -899,10 +899,10 @@ public class TestAsyncTable { .add((Mutation) new Put(row) .addColumn(FAMILY, Bytes.toBytes("D"), Bytes.toBytes("d"))) .add((Mutation) new Delete(row).addColumns(FAMILY, Bytes.toBytes("A"))))).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); - result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get(); - assertEquals("d", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("D")))); + r = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("D"))).get(); + assertEquals("d", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("D")))); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("A"))).get()); } @@ -915,25 +915,25 @@ public class TestAsyncTable { table.put(new Put(row).addColumn(FAMILY, Bytes.toBytes("A"), 100, Bytes.toBytes("a"))).get(); // Put with success - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new FilterList( new FamilyFilter(CompareOperator.EQUAL, new BinaryComparator(FAMILY)), new QualifierFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("A"))), new TimestampsFilter(Collections.singletonList(100L)))) .build(new Put(row).addColumn(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("b")))).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); - Result result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("B"))).get(); - assertEquals("b", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("B")))); + Result r = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("B"))).get(); + assertEquals("b", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("B")))); // Put with failure - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new FilterList( new FamilyFilter(CompareOperator.EQUAL, new BinaryComparator(FAMILY)), new QualifierFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("A"))), new TimestampsFilter(Collections.singletonList(101L)))) .build(new Put(row).addColumn(FAMILY, Bytes.toBytes("C"), Bytes.toBytes("c")))).get(); - assertFalse(ok); + assertFalse(result.isSuccess()); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("C"))).get()); } @@ -947,24 +947,24 @@ public class TestAsyncTable { .get(); // Put with success - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a"))) .timeRange(TimeRange.between(0, 101)) .build(new Put(row).addColumn(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("b")))).get(); - assertTrue(ok); + assertTrue(result.isSuccess()); - Result result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("B"))).get(); - assertEquals("b", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("B")))); + Result r = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("B"))).get(); + assertEquals("b", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("B")))); // Put with failure - ok = table.checkAndMutate(CheckAndMutate.newBuilder(row) + result = table.checkAndMutate(CheckAndMutate.newBuilder(row) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a"))) .timeRange(TimeRange.between(0, 100)) .build(new Put(row).addColumn(FAMILY, Bytes.toBytes("C"), Bytes.toBytes("c")))) .get(); - assertFalse(ok); + assertFalse(result.isSuccess()); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("C"))).get()); } @@ -993,11 +993,11 @@ public class TestAsyncTable { .ifEquals(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("a")) .build(new Put(row2).addColumn(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("f"))); - List results = + List results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); Result result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("A"))).get(); assertEquals("e", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("A")))); @@ -1016,8 +1016,8 @@ public class TestAsyncTable { results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("A"))).get()); @@ -1041,8 +1041,8 @@ public class TestAsyncTable { results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); result = table.get(new Get(row3)).get(); assertEquals("f", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("F")))); @@ -1075,11 +1075,11 @@ public class TestAsyncTable { .ifNotExists(FAMILY, Bytes.toBytes("B")) .build(new Put(row2).addColumn(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("f"))); - List results = + List results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); Result result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("A"))).get(); assertEquals("e", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("A")))); @@ -1098,8 +1098,8 @@ public class TestAsyncTable { results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("A"))).get(); assertEquals("a", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("A")))); @@ -1120,8 +1120,8 @@ public class TestAsyncTable { results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); result = table.get(new Get(row3).addColumn(FAMILY, Bytes.toBytes("C"))).get(); assertEquals("e", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("C")))); @@ -1162,11 +1162,11 @@ public class TestAsyncTable { Bytes.toBytes("b")))) .build(new Put(row2).addColumn(FAMILY, Bytes.toBytes("F"), Bytes.toBytes("h"))); - List results = + List results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); Result result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("C"))).get(); assertEquals("g", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("C")))); @@ -1193,8 +1193,8 @@ public class TestAsyncTable { results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); assertFalse(table.exists(new Get(row).addColumn(FAMILY, Bytes.toBytes("C"))).get()); @@ -1226,8 +1226,8 @@ public class TestAsyncTable { results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); result = table.get(new Get(row)).get(); assertNull(result.getValue(FAMILY, Bytes.toBytes("A"))); @@ -1269,11 +1269,11 @@ public class TestAsyncTable { .timeRange(TimeRange.between(0, 100)) .build(new Put(row2).addColumn(FAMILY, Bytes.toBytes("F"), Bytes.toBytes("h"))); - List results = + List results = table.checkAndMutateAll(Arrays.asList(checkAndMutate1, checkAndMutate2)).get(); - assertTrue(results.get(0)); - assertFalse(results.get(1)); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); Result result = table.get(new Get(row).addColumn(FAMILY, Bytes.toBytes("C"))).get(); assertEquals("g", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("C")))); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncTableBatch.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncTableBatch.java index ac82314b607..cb53f307b7a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncTableBatch.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncTableBatch.java @@ -367,11 +367,11 @@ public class TestAsyncTableBatch { List actions = Arrays.asList(checkAndMutate1, get, mutations, checkAndMutate2, put); List results = table.batchAll(actions).get(); - assertTrue(((Result) results.get(0)).getExists()); + assertTrue(((CheckAndMutateResult) results.get(0)).isSuccess()); assertEquals("b", Bytes.toString(((Result) results.get(1)).getValue(FAMILY, Bytes.toBytes("B")))); assertTrue(((Result) results.get(2)).getExists()); - assertFalse(((Result) results.get(3)).getExists()); + assertFalse(((CheckAndMutateResult) results.get(3)).isSuccess()); assertTrue(((Result) results.get(4)).isEmpty()); Result result = table.get(new Get(row1)).get(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCheckAndMutate.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCheckAndMutate.java index 67dad1958ca..72524c47695 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCheckAndMutate.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCheckAndMutate.java @@ -26,6 +26,7 @@ import static org.junit.Assert.fail; import java.io.IOException; import java.util.Arrays; import java.util.Collections; +import java.util.List; import org.apache.hadoop.hbase.CompareOperator; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; @@ -367,10 +368,10 @@ public class TestCheckAndMutate { // put the same row again with C column deleted RowMutations rm = makeRowMutationsWithColumnCDeleted(); - boolean res = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + CheckAndMutateResult res = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifEquals(FAMILY, Bytes.toBytes("A"), Bytes.toBytes("a")) .build(rm)); - assertTrue(res); + assertTrue(res.isSuccess()); // get row back and assert the values getOneRowAndAssertAllButCExist(table); @@ -401,45 +402,45 @@ public class TestCheckAndMutate { getOneRowAndAssertAllExist(table); // Put with success - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a"))) .build(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"), Bytes.toBytes("d")))); - assertTrue(ok); + assertTrue(result.isSuccess()); - Result result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"))); - assertEquals("d", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("D")))); + Result r = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"))); + assertEquals("d", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("D")))); // Put with failure - ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("b"))) .build(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("E"), Bytes.toBytes("e")))); - assertFalse(ok); + assertFalse(result.isSuccess()); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("E")))); // Delete with success - ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a"))) .build(new Delete(ROWKEY).addColumns(FAMILY, Bytes.toBytes("D")))); - assertTrue(ok); + assertTrue(result.isSuccess()); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D")))); // Mutate with success - ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("B"), CompareOperator.EQUAL, Bytes.toBytes("b"))) .build(new RowMutations(ROWKEY) .add((Mutation) new Put(ROWKEY) .addColumn(FAMILY, Bytes.toBytes("D"), Bytes.toBytes("d"))) .add((Mutation) new Delete(ROWKEY).addColumns(FAMILY, Bytes.toBytes("A"))))); - assertTrue(ok); + assertTrue(result.isSuccess()); - result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"))); - assertEquals("d", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("D")))); + r = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"))); + assertEquals("d", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("D")))); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("A")))); } @@ -454,44 +455,44 @@ public class TestCheckAndMutate { getOneRowAndAssertAllExist(table); // Put with success - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new FilterList( new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a")), new SingleColumnValueFilter(FAMILY, Bytes.toBytes("B"), CompareOperator.EQUAL, Bytes.toBytes("b")))) .build(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"), Bytes.toBytes("d")))); - assertTrue(ok); + assertTrue(result.isSuccess()); - Result result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"))); - assertEquals("d", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("D")))); + Result r = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"))); + assertEquals("d", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("D")))); // Put with failure - ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new FilterList( new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a")), new SingleColumnValueFilter(FAMILY, Bytes.toBytes("B"), CompareOperator.EQUAL, Bytes.toBytes("c")))) .build(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("E"), Bytes.toBytes("e")))); - assertFalse(ok); + assertFalse(result.isSuccess()); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("E")))); // Delete with success - ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new FilterList( new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a")), new SingleColumnValueFilter(FAMILY, Bytes.toBytes("B"), CompareOperator.EQUAL, Bytes.toBytes("b")))) .build(new Delete(ROWKEY).addColumns(FAMILY, Bytes.toBytes("D")))); - assertTrue(ok); + assertTrue(result.isSuccess()); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D")))); // Mutate with success - ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new FilterList( new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a")), @@ -501,10 +502,10 @@ public class TestCheckAndMutate { .add((Mutation) new Put(ROWKEY) .addColumn(FAMILY, Bytes.toBytes("D"), Bytes.toBytes("d"))) .add((Mutation) new Delete(ROWKEY).addColumns(FAMILY, Bytes.toBytes("A"))))); - assertTrue(ok); + assertTrue(result.isSuccess()); - result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"))); - assertEquals("d", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("D")))); + r = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("D"))); + assertEquals("d", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("D")))); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("A")))); } @@ -517,25 +518,25 @@ public class TestCheckAndMutate { table.put(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("A"), 100, Bytes.toBytes("a"))); // Put with success - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new FilterList( new FamilyFilter(CompareOperator.EQUAL, new BinaryComparator(FAMILY)), new QualifierFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("A"))), new TimestampsFilter(Collections.singletonList(100L)))) .build(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("b")))); - assertTrue(ok); + assertTrue(result.isSuccess()); - Result result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("B"))); - assertEquals("b", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("B")))); + Result r = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("B"))); + assertEquals("b", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("B")))); // Put with failure - ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new FilterList( new FamilyFilter(CompareOperator.EQUAL, new BinaryComparator(FAMILY)), new QualifierFilter(CompareOperator.EQUAL, new BinaryComparator(Bytes.toBytes("A"))), new TimestampsFilter(Collections.singletonList(101L)))) .build(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("C"), Bytes.toBytes("c")))); - assertFalse(ok); + assertFalse(result.isSuccess()); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("C")))); } @@ -548,23 +549,23 @@ public class TestCheckAndMutate { table.put(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("A"), 100, Bytes.toBytes("a"))); // Put with success - boolean ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + CheckAndMutateResult result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a"))) .timeRange(TimeRange.between(0, 101)) .build(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("b")))); - assertTrue(ok); + assertTrue(result.isSuccess()); - Result result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("B"))); - assertEquals("b", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("B")))); + Result r = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("B"))); + assertEquals("b", Bytes.toString(r.getValue(FAMILY, Bytes.toBytes("B")))); // Put with failure - ok = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) + result = table.checkAndMutate(CheckAndMutate.newBuilder(ROWKEY) .ifMatches(new SingleColumnValueFilter(FAMILY, Bytes.toBytes("A"), CompareOperator.EQUAL, Bytes.toBytes("a"))) .timeRange(TimeRange.between(0, 100)) .build(new Put(ROWKEY).addColumn(FAMILY, Bytes.toBytes("C"), Bytes.toBytes("c")))); - assertFalse(ok); + assertFalse(result.isSuccess()); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("C")))); } @@ -596,10 +597,11 @@ public class TestCheckAndMutate { .ifEquals(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("a")) .build(new Put(ROWKEY2).addColumn(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("f"))); - boolean[] results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); + List results = + table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); Result result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("A"))); assertEquals("e", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("A")))); @@ -618,8 +620,8 @@ public class TestCheckAndMutate { results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("A")))); @@ -643,8 +645,8 @@ public class TestCheckAndMutate { results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); result = table.get(new Get(ROWKEY3)); assertEquals("f", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("F")))); @@ -674,10 +676,11 @@ public class TestCheckAndMutate { .ifNotExists(FAMILY, Bytes.toBytes("B")) .build(new Put(ROWKEY2).addColumn(FAMILY, Bytes.toBytes("B"), Bytes.toBytes("f"))); - boolean[] results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); + List results = + table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); Result result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("A"))); assertEquals("e", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("A")))); @@ -696,8 +699,8 @@ public class TestCheckAndMutate { results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("A"))); assertEquals("a", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("A")))); @@ -718,8 +721,8 @@ public class TestCheckAndMutate { results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); result = table.get(new Get(ROWKEY3).addColumn(FAMILY, Bytes.toBytes("C"))); assertEquals("e", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("C")))); @@ -759,10 +762,11 @@ public class TestCheckAndMutate { Bytes.toBytes("b")))) .build(new Put(ROWKEY2).addColumn(FAMILY, Bytes.toBytes("F"), Bytes.toBytes("h"))); - boolean[] results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); + List results = + table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); Result result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("C"))); assertEquals("g", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("C")))); @@ -789,8 +793,8 @@ public class TestCheckAndMutate { results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); assertFalse(table.exists(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("C")))); @@ -822,8 +826,8 @@ public class TestCheckAndMutate { results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); result = table.get(new Get(ROWKEY)); assertNull(result.getValue(FAMILY, Bytes.toBytes("A"))); @@ -864,10 +868,11 @@ public class TestCheckAndMutate { .timeRange(TimeRange.between(0, 100)) .build(new Put(ROWKEY2).addColumn(FAMILY, Bytes.toBytes("F"), Bytes.toBytes("h"))); - boolean[] results = table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); + List results = + table.checkAndMutate(Arrays.asList(checkAndMutate1, checkAndMutate2)); - assertTrue(results[0]); - assertFalse(results[1]); + assertTrue(results.get(0).isSuccess()); + assertFalse(results.get(1).isSuccess()); Result result = table.get(new Get(ROWKEY).addColumn(FAMILY, Bytes.toBytes("C"))); assertEquals("g", Bytes.toString(result.getValue(FAMILY, Bytes.toBytes("C")))); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide3.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide3.java index ffe1fb7d174..f14b0a02afa 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide3.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide3.java @@ -516,11 +516,11 @@ public class TestFromClientSide3 { Object[] results = new Object[actions.size()]; table.batch(actions, results); - assertTrue(((Result) results[0]).getExists()); + assertTrue(((CheckAndMutateResult) results[0]).isSuccess()); assertEquals("b", Bytes.toString(((Result) results[1]).getValue(FAMILY, Bytes.toBytes("B")))); assertTrue(((Result) results[2]).getExists()); - assertFalse(((Result) results[3]).getExists()); + assertFalse(((CheckAndMutateResult) results[3]).isSuccess()); assertTrue(((Result) results[4]).isEmpty()); Result result = table.get(new Get(row1)); diff --git a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftTable.java b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftTable.java index 9d940808eac..9469f26388e 100644 --- a/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftTable.java +++ b/hbase-thrift/src/main/java/org/apache/hadoop/hbase/thrift2/client/ThriftTable.java @@ -37,6 +37,7 @@ import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Append; import org.apache.hadoop.hbase.client.CheckAndMutate; +import org.apache.hadoop.hbase.client.CheckAndMutateResult; import org.apache.hadoop.hbase.client.Delete; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Increment; @@ -436,12 +437,12 @@ public class ThriftTable implements Table { } @Override - public boolean checkAndMutate(CheckAndMutate checkAndMutate) { + public CheckAndMutateResult checkAndMutate(CheckAndMutate checkAndMutate) { throw new NotImplementedException("Implement later"); } @Override - public boolean[] checkAndMutate(List checkAndMutates) { + public List checkAndMutate(List checkAndMutates) { throw new NotImplementedException("Implement later"); }