GitHub Repository | Product Reference |
Client for reading from and writing to existing Bigtable tables.
This class provides the ability to make remote calls to the backing service. Sample code to get started:
// One instance per application.
BigtableDataClient client = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")
for(Row row : client.readRows(Query.create("[TABLE]"))) {
// Do something with row
}
// Cleanup during application shutdown.
client.close();
Creating a new client is a very expensive operation and should only be done once and shared in an application. However, close() needs to be called on the client object to clean up resources such as threads during application shutdown.
This client can be safely shared across multiple threads except for the Batcher instances
returned from bulk operations, eg. newBulkMutationBatcher()
, newBulkReadRowsBatcher()
.
The surface of this class includes several types of Java methods for each of the API's methods:
- A "flattened" method, like
readRows()
. With this type of method, the fields of the request type have been converted into function parameters. It may be the case that not all fields are available as parameters, and not every API method will have a flattened method entry point. - A "callable" method, like
readRowsCallable()
. This type of method takes no parameters and returns an immutable API callable object, which can be used to initiate calls to the service.
Taking ReadRows as an example for callable:
// These two invocation are equivalent
ServerStream<Row> stream1 = client.readRows(query);
ServerStream<Row> stream2 = client.readRowsCallable().call(query);
// These two invocation are also equivalent
client.readRowsAsync(query, observer);
client.readRowsCallable().call(query, observer);
All RPC related errors are represented as subclasses of com.google.api.gax.rpc.ApiException. For example, a nonexistent table will trigger a com.google.api.gax.rpc.NotFoundException. Async methods will wrap the error inside the future. Synchronous methods will re-throw the async error but will try to preserve the caller's stacktrace by attaching a suppressed exception at the callsite. This allows callers to use typesafe exceptions, without losing their callsite. Streaming methods (ie. readRows) will re-throw the async exception (like sync methods) when starting iteration.
See the individual methods for example code.
This class can be customized by passing in a custom instance of BigtableDataSettings to create(). For example:
To customize credentials:
BigtableDataSettings settings =
BigtableDataSettings.newBuilder()
.setProjectId("[PROJECT]")
.setInstanceId("[INSTANCE]")
.setCredentialsProvider(FixedCredentialsProvider.create(myCredentials))
.build();
BigtableDataClient client = BigtableDataClient.create(settings);
To customize the endpoint:
BigtableDataSettings.Builder settingsBuilder =
BigtableDataSettings.newBuilder()
.setProjectId("[PROJECT]")
.setInstanceId("[INSTANCE]");
settingsBuilder.stubSettings()
.setEndpoint(myEndpoint).build();
BigtableDataClient client = BigtableDataClient.create(settings.build());
Static Methods
create(BigtableDataSettings settings)
public static BigtableDataClient create(BigtableDataSettings settings)
Constructs an instance of BigtableDataClient, using the given settings. The channels are created based on the settings passed in, or defaults for any settings that are not set.
Parameter | |
---|---|
Name | Description |
settings |
BigtableDataSettings |
Returns | |
---|---|
Type | Description |
BigtableDataClient |
Exceptions | |
---|---|
Type | Description |
IOException |
create(String projectId, String instanceId)
public static BigtableDataClient create(String projectId, String instanceId)
Constructs an instance of BigtableDataClient with default settings.
Parameters | |
---|---|
Name | Description |
projectId |
String The project id of the instance to connect to. |
instanceId |
String The id of the instance to connect to. |
Returns | |
---|---|
Type | Description |
BigtableDataClient |
A new client. |
Exceptions | |
---|---|
Type | Description |
IOException |
If any. |
Methods
<RowT>readRowCallable(RowAdapter<RowT> rowAdapter)
public UnaryCallable<Query,RowT> <RowT>readRowCallable(RowAdapter<RowT> rowAdapter)
Reads a single row. This callable allows for customization of the logical representation of a row. It's meant for advanced use cases.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
Query query = Query.create(tableId)
.rowKey("[KEY]")
.filter(FILTERS.qualifier().regex("[COLUMN PREFIX].*"));
// Synchronous invocation
CustomRow row = bigtableDataClient.readRowCallable(new CustomRowAdapter()).call(query));
// Do something with row
}
See Also: com.google.cloud.bigtable.data.v2.models.FiltersFor the filter building DSL., ServerStreamingCallableFor call styles., QueryFor query options.
Parameter | |
---|---|
Name | Description |
rowAdapter |
RowAdapter<RowT> |
Returns | |
---|---|
Type | Description |
UnaryCallable<Query,RowT> |
<RowT>readRowsCallable(RowAdapter<RowT> rowAdapter)
public ServerStreamingCallable<Query,RowT> <RowT>readRowsCallable(RowAdapter<RowT> rowAdapter)
Streams back the results of the query. This callable allows for customization of the logical representation of a row. It's meant for advanced use cases.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
Query query = Query.create(tableId)
.range("[START KEY]", "[END KEY]")
.filter(FILTERS.qualifier().regex("[COLUMN PREFIX].*"));
// Iterator style
try {
for(CustomRow row : bigtableDataClient.readRowsCallable(new CustomRowAdapter()).call(query)) {
// Do something with row
}
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
}
See Also: com.google.cloud.bigtable.data.v2.models.FiltersFor the filter building DSL., ServerStreamingCallableFor call styles., QueryFor query options.
Parameter | |
---|---|
Name | Description |
rowAdapter |
RowAdapter<RowT> |
Returns | |
---|---|
Type | Description |
ServerStreamingCallable<Query,RowT> |
bulkMutateRows(BulkMutation mutation)
public void bulkMutateRows(BulkMutation mutation)
Convenience method to mutate multiple rows in a batch. Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically. This method expects the mutations to be pre-batched.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
BulkMutation batch = BulkMutation.create("[TABLE]");
for (String someValue : someCollection) {
batch.add("[ROW KEY]", Mutation.create().setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]"));
}
bigtableDataClient.bulkMutateRows(batch);
} catch(ApiException e) {
e.printStackTrace();
} catch(MutateRowsException e) {
e.printStackTrace();
}
Parameter | |
---|---|
Name | Description |
mutation |
BulkMutation |
bulkMutateRowsAsync(BulkMutation mutation)
public ApiFuture<Void> bulkMutateRowsAsync(BulkMutation mutation)
Convenience method to mutate multiple rows in a batch. Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically. This method expects the mutations to be pre-batched.
Sample code:
try (BigtableClient bigtableClient = BigtableClient.create("[PROJECT]", "[INSTANCE]")) {
BulkMutation batch = BulkMutation.create("[TABLE]");
for (String someValue : someCollection) {
ApiFuture<Void> entryFuture = batch.add("[ROW KEY]",
Mutation.create().setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]"));
}
ApiFuture<Void> resultFuture = bigtableDataClient.bulkMutateRowsAsync(batch);
ApiFutures.addCallback(resultFuture, new ApiFutureCallback<Void>() {
public void onFailure(Throwable t) {
if (t instanceof BulkMutationFailure) {
System.out.println("Some entries failed to apply");
} else {
t.printStackTrace();
}
}
public void onSuccess(Void ignored) {
System.out.println("Successfully applied all mutation");
}
}, MoreExecutors.directExecutor());
}
Parameter | |
---|---|
Name | Description |
mutation |
BulkMutation |
Returns | |
---|---|
Type | Description |
ApiFuture<Void> |
bulkMutationCallable()
public UnaryCallable<BulkMutation,Void> bulkMutationCallable()
Mutates multiple rows in a batch. Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically. This method expects the mutations to be pre-batched.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
BulkMutation batch = BulkMutation.create("[TABLE]");
for (String someValue : someCollection) {
ApiFuture<Void> entryFuture = batch.add("[ROW KEY]",
Mutation.create().setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]");
}
bigtableDataClient.bulkMutationCallable().call(batch);
}
Returns | |
---|---|
Type | Description |
UnaryCallable<BulkMutation,Void> |
checkAndMutateRow(ConditionalRowMutation mutation)
public Boolean checkAndMutateRow(ConditionalRowMutation mutation)
Convenience method to synchronously mutate a row atomically based on the output of a filter.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
ConditionalRowMutation mutation = ConditionalRowMutation.create("[TABLE]", "[KEY]")
.condition(FILTERS.value().regex("old-value"))
.then(
Mutation.create()
.setCell("[FAMILY]", "[QUALIFIER]", "[VALUE]")
);
Boolean result = bigtableDataClient.checkAndMutateRow(mutation);
} catch(ApiException e) {
e.printStackTrace();
}
Parameter | |
---|---|
Name | Description |
mutation |
ConditionalRowMutation |
Returns | |
---|---|
Type | Description |
Boolean |
checkAndMutateRowAsync(ConditionalRowMutation mutation)
public ApiFuture<Boolean> checkAndMutateRowAsync(ConditionalRowMutation mutation)
Convenience method to asynchronously mutate a row atomically based on the output of a filter.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
ConditionalRowMutation mutation = ConditionalRowMutation.create("[TABLE]", "[KEY]")
.condition(FILTERS.value().regex("old-value"))
.then(
Mutation.create()
.setCell("[FAMILY]", "[QUALIFIER]", "[VALUE]")
);
ApiFuture<Boolean> future = bigtableDataClient.checkAndMutateRowAsync(mutation);
ApiFutures.addCallback(future, new ApiFutureCallback<Boolean>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to mutate a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Boolean wasApplied) {
System.out.println("Row was modified: " + wasApplied);
}
}, MoreExecutors.directExecutor());
}
Parameter | |
---|---|
Name | Description |
mutation |
ConditionalRowMutation |
Returns | |
---|---|
Type | Description |
ApiFuture<Boolean> |
checkAndMutateRowCallable()
public UnaryCallable<ConditionalRowMutation,Boolean> checkAndMutateRowCallable()
Mutates a row atomically based on the output of a filter.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
ConditionalRowMutation mutation = ConditionalRowMutation.create("[TABLE]", "[KEY]")
.condition(FILTERS.value().regex("old-value"))
.then(
Mutation.create()
.setCell("[FAMILY]", "[QUALIFIER]", "[VALUE]")
);
// Sync style
try {
boolean success = bigtableDataClient.checkAndMutateRowCallable().call(mutation);
if (!success) {
System.out.println("Row did not match conditions");
}
} catch (NotFoundException e) {
System.out.println("Tried to mutate a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
}
Returns | |
---|---|
Type | Description |
UnaryCallable<ConditionalRowMutation,Boolean> |
close()
public void close()
Close the clients and releases all associated resources.
executeQuery(Statement statement)
public ResultSet executeQuery(Statement statement)
Executes a SQL Query and returns a ResultSet to iterate over the results. The returned ResultSet instance is not threadsafe, it can only be used from single thread.
Sample code:
{@code try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) { String query = "SELECT CAST(cf['stringCol'] AS STRING) FROM [TABLE]";
try (ResultSet resultSet = bigtableDataClient.executeQuery(Statement.of(query))) { while (resultSet.next()) { String s = resultSet.getString("stringCol"); // do something with data } } catch (RuntimeException e) { e.printStackTrace(); } }
@see Statement For query options.
Parameter | |
---|---|
Name | Description |
statement |
Statement |
Returns | |
---|---|
Type | Description |
ResultSet |
exists(TargetId targetId, ByteString rowKey)
public boolean exists(TargetId targetId, ByteString rowKey)
Confirms synchronously if given row key exists or not on the specified TargetId.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ByteString key = ByteString.copyFromUtf8("key");
boolean isRowPresent = bigtableDataClient.exists(TableId.of(tableId), key);
// Do something with result, for example, display a message
if(isRowPresent) {
System.out.println(key.toStringUtf8() + " is present");
}
} catch(ApiException e) {
e.printStackTrace();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
ByteString |
Returns | |
---|---|
Type | Description |
boolean |
exists(TargetId targetId, String rowKey)
public boolean exists(TargetId targetId, String rowKey)
Confirms synchronously if given row key exists or not on the specified TargetId.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
String key = "key";
boolean isRowPresent = bigtableDataClient.exists(TableId.of(tableId), key);
// Do something with result, for example, display a message
if(isRowPresent) {
System.out.println(key + " is present");
}
} catch(ApiException e) {
e.printStackTrace();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
String |
Returns | |
---|---|
Type | Description |
boolean |
exists(String tableId, ByteString rowKey) (deprecated)
public boolean exists(String tableId, ByteString rowKey)
Deprecated. Please use BigtableDataClient#exists(TargetId, ByteString) instead.
Confirms synchronously if given row key exists or not.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ByteString key = ByteString.copyFromUtf8("key");
boolean isRowPresent = bigtableDataClient.exists(tableId, key);
// Do something with result, for example, display a message
if(isRowPresent) {
System.out.println(key.toStringUtf8() + " is present");
}
} catch(ApiException e) {
e.printStackTrace();
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
ByteString |
Returns | |
---|---|
Type | Description |
boolean |
exists(String tableId, String rowKey) (deprecated)
public boolean exists(String tableId, String rowKey)
Deprecated. Please use BigtableDataClient#exists(TargetId, String) instead.
Confirms synchronously if given row key exists or not.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
String key = "key";
boolean isRowPresent = bigtableDataClient.exists(tableId, key);
// Do something with result, for example, display a message
if(isRowPresent) {
System.out.println(key + " is present");
}
} catch(ApiException e) {
e.printStackTrace();
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
String |
Returns | |
---|---|
Type | Description |
boolean |
existsAsync(TargetId targetId, ByteString rowKey)
public ApiFuture<Boolean> existsAsync(TargetId targetId, ByteString rowKey)
Confirms asynchronously if given row key exists or not on the specified TargetId.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
final ByteString key = ByteString.copyFromUtf8("key");
ApiFuture<Boolean> futureResult = bigtableDataClient.existsAsync(TableId.of(tableId), key);
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Boolean>() {
public void onFailure(Throwable t) {
t.printStackTrace();
}
public void onSuccess(Boolean isRowPresent) {
if(isRowPresent) {
System.out.println(key.toStringUtf8() + " is present");
}
}
}, MoreExecutors.directExecutor());
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
ByteString |
Returns | |
---|---|
Type | Description |
ApiFuture<Boolean> |
existsAsync(TargetId targetId, String rowKey)
public ApiFuture<Boolean> existsAsync(TargetId targetId, String rowKey)
Confirms asynchronously if given row key exists or not on the specified TargetId.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
final String key = "key";
ApiFuture<Boolean> futureResult = bigtableDataClient.existsAsync(TableId.of(tableId), key);
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Boolean>() {
public void onFailure(Throwable t) {
t.printStackTrace();
}
public void onSuccess(Boolean isRowPresent) {
if(isRowPresent) {
System.out.println(key + " is present");
}
}
}, MoreExecutors.directExecutor());
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
String |
Returns | |
---|---|
Type | Description |
ApiFuture<Boolean> |
existsAsync(String tableId, ByteString rowKey) (deprecated)
public ApiFuture<Boolean> existsAsync(String tableId, ByteString rowKey)
Deprecated. Please use BigtableDataClient#existsAsync(TargetId, ByteString) instead.
Confirms asynchronously if given row key exists or not.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
final ByteString key = ByteString.copyFromUtf8("key");
ApiFuture<Boolean> futureResult = bigtableDataClient.existsAsync(tableId, key);
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Boolean>() {
public void onFailure(Throwable t) {
t.printStackTrace();
}
public void onSuccess(Boolean isRowPresent) {
if(isRowPresent) {
System.out.println(key.toStringUtf8() + " is present");
}
}
}, MoreExecutors.directExecutor());
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
ByteString |
Returns | |
---|---|
Type | Description |
ApiFuture<Boolean> |
existsAsync(String tableId, String rowKey) (deprecated)
public ApiFuture<Boolean> existsAsync(String tableId, String rowKey)
Deprecated. Please use BigtableDataClient#existsAsync(TargetId, String) instead.
Confirms asynchronously if given row key exists or not.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
final String key = "key";
ApiFuture<Boolean> futureResult = bigtableDataClient.existsAsync(tableId, key);
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Boolean>() {
public void onFailure(Throwable t) {
t.printStackTrace();
}
public void onSuccess(Boolean isRowPresent) {
if(isRowPresent) {
System.out.println(key + " is present");
}
}
}, MoreExecutors.directExecutor());
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
String |
Returns | |
---|---|
Type | Description |
ApiFuture<Boolean> |
generateInitialChangeStreamPartitions(String tableId)
public ServerStream<Range.ByteStringRange> generateInitialChangeStreamPartitions(String tableId)
Convenience method for synchronously streaming the partitions of a table. The returned ServerStream instance is not threadsafe, it can only be used from single thread.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
try {
ServerStream<ByteStringRange> stream = bigtableDataClient.generateInitialChangeStreamPartitions(tableId);
int count = 0;
// Iterator style
for (ByteStringRange partition : stream) {
if (++count > 10) {
stream.cancel();
break;
}
// Do something with partition
}
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
}
See Also: ServerStreamingCallableFor call styles.
Parameter | |
---|---|
Name | Description |
tableId |
String |
Returns | |
---|---|
Type | Description |
ServerStream<ByteStringRange> |
generateInitialChangeStreamPartitionsAsync(String tableId, ResponseObserver<Range.ByteStringRange> observer)
public void generateInitialChangeStreamPartitionsAsync(String tableId, ResponseObserver<Range.ByteStringRange> observer)
Convenience method for asynchronously streaming the partitions of a table.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
bigtableDataClient.generateInitialChangeStreamPartitionsAsync(tableId, new ResponseObserver<RowRange>() {
StreamController controller;
int count = 0;
public void onStart(StreamController controller) {
this.controller = controller;
}
public void onResponse(ByteStringRange partition) {
if (++count > 10) {
controller.cancel();
return;
}
// Do something with partition
}
public void onError(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onComplete() {
// Handle stream completion
}
});
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
observer |
ResponseObserver<ByteStringRange> |
generateInitialChangeStreamPartitionsCallable()
public ServerStreamingCallable<String,Range.ByteStringRange> generateInitialChangeStreamPartitionsCallable()
Streams back the results of the query. The returned callable object allows for customization of api invocation.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Iterator style
try {
for(ByteStringRange partition : bigtableDataClient.generateInitialChangeStreamPartitionsCallable().call(tableId)) {
// Do something with partition
}
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
// Sync style
try {
List<ByteStringRange> partitions = bigtableDataClient.generateInitialChangeStreamPartitionsCallable().all().call(tableId);
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
// Point look up
ApiFuture<ByteStringRange> partitionFuture =
bigtableDataClient.generateInitialChangeStreamPartitionsCallable().first().futureCall(tableId);
ApiFutures.addCallback(partitionFuture, new ApiFutureCallback<ByteStringRange>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(RowRange result) {
System.out.println("Got partition: " + result);
}
}, MoreExecutors.directExecutor());
// etc
}
See Also: ServerStreamingCallableFor call styles.
Returns | |
---|---|
Type | Description |
ServerStreamingCallable<String,ByteStringRange> |
mutateRow(RowMutation rowMutation)
public void mutateRow(RowMutation rowMutation)
Convenience method to synchronously mutate a single row atomically. Cells already present in the row are left unchanged unless explicitly changed by the RowMutation.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
RowMutation mutation = RowMutation.create("[TABLE]", "[ROW KEY]")
.setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]");
bigtableDataClient.mutateRow(mutation);
} catch(ApiException e) {
e.printStackTrace();
}
Parameter | |
---|---|
Name | Description |
rowMutation |
RowMutation |
mutateRowAsync(RowMutation rowMutation)
public ApiFuture<Void> mutateRowAsync(RowMutation rowMutation)
Convenience method to asynchronously mutate a single row atomically. Cells already present in the row are left unchanged unless explicitly changed by the RowMutation.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
RowMutation mutation = RowMutation.create("[TABLE]", "[ROW KEY]")
.setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]");
ApiFuture<Void> future = bigtableDataClient.mutateRowAsync(mutation);
ApiFutures.addCallback(future, new ApiFutureCallback<Void>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to mutate a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Void ignored) {
System.out.println("Successfully applied mutation");
}
}, MoreExecutors.directExecutor());
}
Parameter | |
---|---|
Name | Description |
rowMutation |
RowMutation |
Returns | |
---|---|
Type | Description |
ApiFuture<Void> |
mutateRowCallable()
public UnaryCallable<RowMutation,Void> mutateRowCallable()
Mutates a single row atomically. Cells already present in the row are left unchanged unless explicitly changed by the RowMutation.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
RowMutation mutation = RowMutation.create("[TABLE]", "[ROW KEY]")
.setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]");
// Sync style
try {
bigtableDataClient.mutateRowCallable().call(mutation);
} catch (NotFoundException e) {
System.out.println("Tried to mutate a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
}
Returns | |
---|---|
Type | Description |
UnaryCallable<RowMutation,Void> |
newBulkMutationBatcher(TargetId targetId)
public Batcher<RowMutationEntry,Void> newBulkMutationBatcher(TargetId targetId)
Mutates multiple rows in a batch on the specified TargetId.
Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically. The returned Batcher instance is not threadsafe, it can only be used from single thread.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
try (Batcher<RowMutationEntry, Void> batcher = bigtableDataClient.newBulkMutationBatcher(TableId.of("[TABLE]"))) {
for (String someValue : someCollection) {
ApiFuture<Void> entryFuture =
batcher.add(
RowMutationEntry.create("[ROW KEY]")
.setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]"));
}
// Blocks until mutations are applied on all submitted row entries.
batcher.flush();
}
// Before batcher
is closed, all remaining(If any) mutations are applied.
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameter | |
---|---|
Name | Description |
targetId |
TargetId |
Returns | |
---|---|
Type | Description |
Batcher<RowMutationEntry,Void> |
newBulkMutationBatcher(TargetId targetId, GrpcCallContext ctx)
public Batcher<RowMutationEntry,Void> newBulkMutationBatcher(TargetId targetId, GrpcCallContext ctx)
Mutates multiple rows in a batch on the specified TargetId.
Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically. The returned Batcher instance is not threadsafe, it can only be used from single thread. This method allows customization of the underlying RPCs by passing in a com.google.api.gax.grpc.GrpcCallContext. The same context will be reused for all batches. This can be used to customize things like per attempt timeouts.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
GrpcCallContext ctx = GrpcCallContext.createDefault().withTimeout(Duration.ofSeconds(10));
try (Batcher<RowMutationEntry, Void> batcher = bigtableDataClient.newBulkMutationBatcher(TableId.of("[TABLE]"), ctx)) {
for (String someValue : someCollection) {
ApiFuture<Void> entryFuture =
batcher.add(
RowMutationEntry.create("[ROW KEY]")
.setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]"));
}
// Blocks until mutations are applied on all submitted row entries.
batcher.flush();
}
// Before batcher
is closed, all remaining(If any) mutations are applied.
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
ctx |
GrpcCallContext |
Returns | |
---|---|
Type | Description |
Batcher<RowMutationEntry,Void> |
newBulkMutationBatcher(String tableId) (deprecated)
public Batcher<RowMutationEntry,Void> newBulkMutationBatcher(String tableId)
Deprecated. Please use BigtableDataClient#newBulkMutationBatcher(TargetId) instead.
Mutates multiple rows in a batch. Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically. The returned Batcher instance is not threadsafe, it can only be used from single thread.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
try (Batcher<RowMutationEntry, Void> batcher = bigtableDataClient.newBulkMutationBatcher("[TABLE]")) {
for (String someValue : someCollection) {
ApiFuture<Void> entryFuture =
batcher.add(
RowMutationEntry.create("[ROW KEY]")
.setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]"));
}
// Blocks until mutations are applied on all submitted row entries.
batcher.flush();
}
// Before batcher
is closed, all remaining(If any) mutations are applied.
}
Parameter | |
---|---|
Name | Description |
tableId |
String |
Returns | |
---|---|
Type | Description |
Batcher<RowMutationEntry,Void> |
newBulkMutationBatcher(String tableId, GrpcCallContext ctx) (deprecated)
public Batcher<RowMutationEntry,Void> newBulkMutationBatcher(String tableId, GrpcCallContext ctx)
Deprecated. Please use BigtableDataClient#newBulkMutationBatcher(TargetId, GrpcCallContext) instead.
Mutates multiple rows in a batch. Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically. The returned Batcher instance is not threadsafe, it can only be used from single thread. This method allows customization of the underlying RPCs by passing in a com.google.api.gax.grpc.GrpcCallContext. The same context will be reused for all batches. This can be used to customize things like per attempt timeouts.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
try (Batcher<RowMutationEntry, Void> batcher = bigtableDataClient.newBulkMutationBatcher("[TABLE]", GrpcCallContext.createDefault().withTimeout(Duration.ofSeconds(10)))) {
for (String someValue : someCollection) {
ApiFuture<Void> entryFuture =
batcher.add(
RowMutationEntry.create("[ROW KEY]")
.setCell("[FAMILY NAME]", "[QUALIFIER]", "[VALUE]"));
}
// Blocks until mutations are applied on all submitted row entries.
batcher.flush();
}
// Before batcher
is closed, all remaining(If any) mutations are applied.
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
ctx |
GrpcCallContext |
Returns | |
---|---|
Type | Description |
Batcher<RowMutationEntry,Void> |
newBulkReadRowsBatcher(TargetId targetId)
public Batcher<ByteString,Row> newBulkReadRowsBatcher(TargetId targetId)
Reads rows for given tableId in a batch on the specified TargetId.
If the row does not exist, the value will be null. The returned Batcher instance is not threadsafe, it can only be used from a single thread.
Performance notice: The ReadRows protocol requires that rows are sent in ascending key order, which means that the keys are processed sequentially on the server-side, so batching allows improving throughput but not latency. Lower latencies can be achieved by sending smaller requests concurrently.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
List<ApiFuture<Row>> rows = new ArrayList<>();
try (Batcher<ByteString, Row> batcher = bigtableDataClient.newBulkReadRowsBatcher(TableId.of("[TABLE]"))) {
for (String someValue : someCollection) {
ApiFuture<Row> rowFuture =
batcher.add(ByteString.copyFromUtf8("[ROW KEY]"));
rows.add(rowFuture);
}
// [Optional] Sends collected elements for batching asynchronously.
batcher.sendOutstanding();
// [Optional] Invokes sendOutstanding() and awaits until all pending entries are resolved.
batcher.flush();
}
// batcher.close() invokes flush()
which will in turn invoke sendOutstanding()
with await for
pending batches until its resolved.
List<Row> actualRows = ApiFutures.allAsList(rows).get();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameter | |
---|---|
Name | Description |
targetId |
TargetId |
Returns | |
---|---|
Type | Description |
Batcher<ByteString,Row> |
newBulkReadRowsBatcher(TargetId targetId, Filters.Filter filter)
public Batcher<ByteString,Row> newBulkReadRowsBatcher(TargetId targetId, Filters.Filter filter)
Reads rows for given tableId and filter criteria in a batch on the specified TargetId.
If the row does not exist, the value will be null. The returned Batcher instance is not threadsafe, it can only be used from a single thread.
Performance notice: The ReadRows protocol requires that rows are sent in ascending key order, which means that the keys are processed sequentially on the server-side, so batching allows improving throughput but not latency. Lower latencies can be achieved by sending smaller requests concurrently.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
// Build the filter expression
Filter filter = FILTERS.chain()
.filter(FILTERS.key().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
List<ApiFuture<Row>> rows = new ArrayList<>();
try (Batcher<ByteString, Row> batcher = bigtableDataClient.newBulkReadRowsBatcher(TableId.of("[TABLE]"), filter)) {
for (String someValue : someCollection) {
ApiFuture<Row> rowFuture =
batcher.add(ByteString.copyFromUtf8("[ROW KEY]"));
rows.add(rowFuture);
}
// [Optional] Sends collected elements for batching asynchronously.
batcher.sendOutstanding();
// [Optional] Invokes sendOutstanding() and awaits until all pending entries are resolved.
batcher.flush();
}
// batcher.close() invokes flush()
which will in turn invoke sendOutstanding()
with await for
pending batches until its resolved.
List<Row> actualRows = ApiFutures.allAsList(rows).get();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
Batcher<ByteString,Row> |
newBulkReadRowsBatcher(TargetId targetId, Filters.Filter filter, GrpcCallContext ctx)
public Batcher<ByteString,Row> newBulkReadRowsBatcher(TargetId targetId, Filters.Filter filter, GrpcCallContext ctx)
Reads rows for given tableId and filter criteria in a batch on the specified TargetId.
If the row does not exist, the value will be null. The returned Batcher instance is not threadsafe, it can only be used from a single thread. This method allows customization of the underlying RPCs by passing in a com.google.api.gax.grpc.GrpcCallContext. The same context will be reused for all batches. This can be used to customize things like per attempt timeouts.
Performance notice: The ReadRows protocol requires that rows are sent in ascending key order, which means that the keys are processed sequentially on the server-side, so batching allows improving throughput but not latency. Lower latencies can be achieved by sending smaller requests concurrently.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
// Build the filter expression
Filter filter = FILTERS.chain()
.filter(FILTERS.key().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
List<ApiFuture<Row>> rows = new ArrayList<>();
try (Batcher<ByteString, Row> batcher = bigtableDataClient.newBulkReadRowsBatcher(
TableId.of("[TABLE]"), filter, GrpcCallContext.createDefault().withTimeout(Duration.ofSeconds(10)))) {
for (String someValue : someCollection) {
ApiFuture<Row> rowFuture =
batcher.add(ByteString.copyFromUtf8("[ROW KEY]"));
rows.add(rowFuture);
}
// [Optional] Sends collected elements for batching asynchronously.
batcher.sendOutstanding();
// [Optional] Invokes sendOutstanding() and awaits until all pending entries are resolved.
batcher.flush();
}
// batcher.close() invokes flush()
which will in turn invoke sendOutstanding()
with await for
pending batches until its resolved.
List<Row> actualRows = ApiFutures.allAsList(rows).get();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
filter |
Filters.Filter |
ctx |
GrpcCallContext |
Returns | |
---|---|
Type | Description |
Batcher<ByteString,Row> |
newBulkReadRowsBatcher(String tableId) (deprecated)
public Batcher<ByteString,Row> newBulkReadRowsBatcher(String tableId)
Deprecated. Please use BigtableDataClient#newBulkReadRowsBatcher(TargetId) instead.
Reads rows for given tableId in a batch. If the row does not exist, the value will be null. The returned Batcher instance is not threadsafe, it can only be used from a single thread.
Performance notice: The ReadRows protocol requires that rows are sent in ascending key order, which means that the keys are processed sequentially on the server-side, so batching allows improving throughput but not latency. Lower latencies can be achieved by sending smaller requests concurrently.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
List<ApiFuture<Row>> rows = new ArrayList<>();
try (Batcher<ByteString, Row> batcher = bigtableDataClient.newBulkReadRowsBatcher("[TABLE]")) {
for (String someValue : someCollection) {
ApiFuture<Row> rowFuture =
batcher.add(ByteString.copyFromUtf8("[ROW KEY]"));
rows.add(rowFuture);
}
// [Optional] Sends collected elements for batching asynchronously.
batcher.sendOutstanding();
// [Optional] Invokes sendOutstanding() and awaits until all pending entries are resolved.
batcher.flush();
}
// batcher.close() invokes flush()
which will in turn invoke sendOutstanding()
with await for
pending batches until its resolved.
List<Row> actualRows = ApiFutures.allAsList(rows).get();
}
Parameter | |
---|---|
Name | Description |
tableId |
String |
Returns | |
---|---|
Type | Description |
Batcher<ByteString,Row> |
newBulkReadRowsBatcher(String tableId, Filters.Filter filter) (deprecated)
public Batcher<ByteString,Row> newBulkReadRowsBatcher(String tableId, Filters.Filter filter)
Deprecated. Please use BigtableDataClient#newBulkReadRowsBatcher(TargetId, Filter) instead.
Reads rows for given tableId and filter criteria in a batch. If the row does not exist, the value will be null. The returned Batcher instance is not threadsafe, it can only be used from a single thread.
Performance notice: The ReadRows protocol requires that rows are sent in ascending key order, which means that the keys are processed sequentially on the server-side, so batching allows improving throughput but not latency. Lower latencies can be achieved by sending smaller requests concurrently.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
// Build the filter expression
Filter filter = FILTERS.chain()
.filter(FILTERS.key().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
List<ApiFuture<Row>> rows = new ArrayList<>();
try (Batcher<ByteString, Row> batcher = bigtableDataClient.newBulkReadRowsBatcher("[TABLE]", filter)) {
for (String someValue : someCollection) {
ApiFuture<Row> rowFuture =
batcher.add(ByteString.copyFromUtf8("[ROW KEY]"));
rows.add(rowFuture);
}
// [Optional] Sends collected elements for batching asynchronously.
batcher.sendOutstanding();
// [Optional] Invokes sendOutstanding() and awaits until all pending entries are resolved.
batcher.flush();
}
// batcher.close() invokes flush()
which will in turn invoke sendOutstanding()
with await for
pending batches until its resolved.
List<Row> actualRows = ApiFutures.allAsList(rows).get();
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
Batcher<ByteString,Row> |
newBulkReadRowsBatcher(String tableId, Filters.Filter filter, GrpcCallContext ctx) (deprecated)
public Batcher<ByteString,Row> newBulkReadRowsBatcher(String tableId, Filters.Filter filter, GrpcCallContext ctx)
Deprecated. Please use BigtableDataClient#newBulkReadRowsBatcher(TargetId, Filter, GrpcCallContext) instead.
Reads rows for given tableId and filter criteria in a batch. If the row does not exist, the value will be null. The returned Batcher instance is not threadsafe, it can only be used from a single thread. This method allows customization of the underlying RPCs by passing in a com.google.api.gax.grpc.GrpcCallContext. The same context will be reused for all batches. This can be used to customize things like per attempt timeouts.
Performance notice: The ReadRows protocol requires that rows are sent in ascending key order, which means that the keys are processed sequentially on the server-side, so batching allows improving throughput but not latency. Lower latencies can be achieved by sending smaller requests concurrently.
Sample Code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
// Build the filter expression
Filter filter = FILTERS.chain()
.filter(FILTERS.key().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
List<ApiFuture<Row>> rows = new ArrayList<>();
try (Batcher<ByteString, Row> batcher = bigtableDataClient.newBulkReadRowsBatcher(
"[TABLE]", filter, GrpcCallContext.createDefault().withTimeout(Duration.ofSeconds(10)))) {
for (String someValue : someCollection) {
ApiFuture<Row> rowFuture =
batcher.add(ByteString.copyFromUtf8("[ROW KEY]"));
rows.add(rowFuture);
}
// [Optional] Sends collected elements for batching asynchronously.
batcher.sendOutstanding();
// [Optional] Invokes sendOutstanding() and awaits until all pending entries are resolved.
batcher.flush();
}
// batcher.close() invokes flush()
which will in turn invoke sendOutstanding()
with await for
pending batches until its resolved.
List<Row> actualRows = ApiFutures.allAsList(rows).get();
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
filter |
Filters.Filter |
ctx |
GrpcCallContext |
Returns | |
---|---|
Type | Description |
Batcher<ByteString,Row> |
readChangeStream(ReadChangeStreamQuery query)
public ServerStream<ChangeStreamRecord> readChangeStream(ReadChangeStreamQuery query)
Convenience method for synchronously streaming the results of a ReadChangeStreamQuery. The returned ServerStream instance is not threadsafe, it can only be used from single thread.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ReadChangeStreamQuery query = ReadChangeStreamQuery.create(tableId)
.streamPartition("START_KEY", "END_KEY")
.startTime(Timestamp.newBuilder().setSeconds(100).build());
try {
ServerStream<ChangeStreamRecord> stream = bigtableDataClient.readChangeStream(query);
int count = 0;
// Iterator style
for (ChangeStreamRecord record : stream) {
if (++count > 10) {
stream.cancel();
break;
}
// Do something with the change stream record.
}
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
}
See Also: ReadChangeStreamQueryFor query options., ServerStreamingCallableFor call styles.
Parameter | |
---|---|
Name | Description |
query |
ReadChangeStreamQuery |
Returns | |
---|---|
Type | Description |
ServerStream<ChangeStreamRecord> |
readChangeStreamAsync(ReadChangeStreamQuery query, ResponseObserver<ChangeStreamRecord> observer)
public void readChangeStreamAsync(ReadChangeStreamQuery query, ResponseObserver<ChangeStreamRecord> observer)
Convenience method for asynchronously streaming the results of a ReadChangeStreamQuery.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ReadChangeStreamQuery query = ReadChangeStreamQuery.create(tableId)
.streamPartition("START_KEY", "END_KEY")
.startTime(Timestamp.newBuilder().setSeconds(100).build());
bigtableDataClient.readChangeStreamAsync(query, new ResponseObserver<ChangeStreamRecord>() {
StreamController controller;
int count = 0;
public void onStart(StreamController controller) {
this.controller = controller;
}
public void onResponse(ChangeStreamRecord record) {
if (++count > 10) {
controller.cancel();
return;
}
// Do something with the change stream record.
}
public void onError(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onComplete() {
// Handle stream completion
}
});
}
Parameters | |
---|---|
Name | Description |
query |
ReadChangeStreamQuery |
observer |
ResponseObserver<ChangeStreamRecord> |
readChangeStreamCallable()
public ServerStreamingCallable<ReadChangeStreamQuery,ChangeStreamRecord> readChangeStreamCallable()
Streams back the results of the query. The returned callable object allows for customization of api invocation.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ReadChangeStreamQuery query = ReadChangeStreamQuery.create(tableId)
.streamPartition("START_KEY", "END_KEY")
.startTime(Timestamp.newBuilder().setSeconds(100).build());
// Iterator style
try {
for(ChangeStreamRecord record : bigtableDataClient.readChangeStreamCallable().call(query)) {
// Do something with record
}
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
// Sync style
try {
List<ChangeStreamRecord> records = bigtableDataClient.readChangeStreamCallable().all().call(query);
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
// Point look up
ApiFuture<ChangeStreamRecord> recordFuture =
bigtableDataClient.readChangeStreamCallable().first().futureCall(query);
ApiFutures.addCallback(recordFuture, new ApiFutureCallback<ChangeStreamRecord>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(ChangeStreamRecord result) {
System.out.println("Got record: " + result);
}
}, MoreExecutors.directExecutor());
// etc
}
See Also: ReadChangeStreamQueryFor query options., ServerStreamingCallableFor call styles.
Returns | |
---|---|
Type | Description |
ServerStreamingCallable<ReadChangeStreamQuery,ChangeStreamRecord> |
readModifyWriteRow(ReadModifyWriteRow mutation)
public Row readModifyWriteRow(ReadModifyWriteRow mutation)
Convenience method that synchronously modifies a row atomically on the server. The method reads the latest existing timestamp and value from the specified columns and writes a new entry. The new value for the timestamp is the greater of the existing timestamp or the current server time. The method returns the new contents of all modified cells.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
ReadModifyWriteRow mutation = ReadModifyWriteRow.create("[TABLE]", "[KEY]")
.increment("[FAMILY]", "[QUALIFIER]", 1)
.append("[FAMILY2]", "[QUALIFIER2]", "suffix");
Row success = bigtableDataClient.readModifyWriteRow(mutation);
} catch(ApiException e) {
e.printStackTrace();
}
Parameter | |
---|---|
Name | Description |
mutation |
ReadModifyWriteRow |
Returns | |
---|---|
Type | Description |
Row |
readModifyWriteRowAsync(ReadModifyWriteRow mutation)
public ApiFuture<Row> readModifyWriteRowAsync(ReadModifyWriteRow mutation)
Convenience method that asynchronously modifies a row atomically on the server. The method reads the latest existing timestamp and value from the specified columns and writes a new entry. The new value for the timestamp is the greater of the existing timestamp or the current server time. The method returns the new contents of all modified cells.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
ReadModifyWriteRow mutation = ReadModifyWriteRow.create("[TABLE]", "[KEY]")
.increment("[FAMILY]", "[QUALIFIER]", 1)
.append("[FAMILY2]", "[QUALIFIER2]", "suffix");
ApiFuture<Row> rowFuture = bigtableDataClient.readModifyWriteRowAsync(mutation);
ApiFutures.addCallback(rowFuture, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to mutate a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row resultingRow) {
System.out.println("Resulting row: " + resultingRow);
}
}, MoreExecutors.directExecutor());
}
Parameter | |
---|---|
Name | Description |
mutation |
ReadModifyWriteRow |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readModifyWriteRowCallable()
public UnaryCallable<ReadModifyWriteRow,Row> readModifyWriteRowCallable()
Modifies a row atomically on the server. The method reads the latest existing timestamp and value from the specified columns and writes a new entry. The new value for the timestamp is the greater of the existing timestamp or the current server time. The method returns the new contents of all modified cells.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
ReadModifyWriteRow mutation = ReadModifyWriteRow.create("[TABLE]", "[KEY]")
.increment("[FAMILY]", "[QUALIFIER]", 1)
.append("[FAMILY2]", "[QUALIFIER2]", "suffix");
try {
Row row = bigtableDataClient.readModifyWriteRowCallable().call(mutation);
} catch (NotFoundException e) {
System.out.println("Tried to mutate a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
}
Returns | |
---|---|
Type | Description |
UnaryCallable<ReadModifyWriteRow,Row> |
readRow(TargetId targetId, ByteString rowKey)
public Row readRow(TargetId targetId, ByteString rowKey)
Convenience method for synchronously reading a single row on the specified TargetId. If the row does not exist, the value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
Row row = bigtableDataClient.readRow(TableId.of(tableId), ByteString.copyFromUtf8("key"));
// Do something with row, for example, display all cells
if(row != null) {
System.out.println(row.getKey().toStringUtf8());
for(RowCell cell : row.getCells()) {
System.out.printf("Family: %s Qualifier: %s Value: %s", cell.getFamily(),
cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
}
}
} catch(ApiException e) {
e.printStackTrace();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
ByteString |
Returns | |
---|---|
Type | Description |
Row |
readRow(TargetId targetId, ByteString rowKey, Filters.Filter filter)
public Row readRow(TargetId targetId, ByteString rowKey, Filters.Filter filter)
Convenience method for synchronously reading a single row on the specified TargetId. If the row does not exist, the value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Build the filter expression
Filter filter = FILTERS.chain()
.filter(FILTERS.qualifier().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
Row row = bigtableDataClient.readRow(TableId.of(tableId), ByteString.copyFromUtf8("key"), filter);
// Do something with row, for example, display all cells
if(row != null) {
System.out.println(row.getKey().toStringUtf8());
for(RowCell cell : row.getCells()) {
System.out.printf("Family: %s Qualifier: %s Value: %s", cell.getFamily(),
cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
}
}
} catch(ApiException e) {
e.printStackTrace();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
ByteString |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
Row |
readRow(TargetId targetId, String rowKey)
public Row readRow(TargetId targetId, String rowKey)
Convenience method for synchronously reading a single row on the specified TargetId. If the row does not exist, the value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
Row row = bigtableDataClient.readRow(TableId.of(tableId), "key");
// Do something with row, for example, display all cells
if(row != null) {
System.out.println(row.getKey().toStringUtf8());
for(RowCell cell : row.getCells()) {
System.out.printf("Family: %s Qualifier: %s Value: %s", cell.getFamily(),
cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
}
}
} catch(ApiException e) {
e.printStackTrace();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
String |
Returns | |
---|---|
Type | Description |
Row |
readRow(TargetId targetId, String rowKey, Filters.Filter filter)
public Row readRow(TargetId targetId, String rowKey, Filters.Filter filter)
Convenience method for synchronously reading a single row on the specified TargetId. If the row does not exist, the value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Build the filter expression
Filter filter = FILTERS.chain()
.filter(FILTERS.qualifier().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
Row row = bigtableDataClient.readRow(TableId.of(tableId), "key", filter);
// Do something with row, for example, display all cells
if(row != null) {
System.out.println(row.getKey().toStringUtf8());
for(RowCell cell : row.getCells()) {
System.out.printf("Family: %s Qualifier: %s Value: %s", cell.getFamily(),
cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
}
}
} catch(ApiException e) {
e.printStackTrace();
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
String |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
Row |
readRow(String tableId, ByteString rowKey) (deprecated)
public Row readRow(String tableId, ByteString rowKey)
Deprecated. Please use BigtableDataClient#readRow(TargetId, ByteString) instead.
Convenience method for synchronously reading a single row. If the row does not exist, the value will be null.
Sample code:
{code try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) { String tableId = "[TABLE]";
Row row = bigtableDataClient.readRow(tableId, ByteString.copyFromUtf8("key")); // Do something with row, for example, display all cells if(row != null) { System.out.println(row.getKey().toStringUtf8()); for(RowCell cell : row.getCells()) { System.out.printf("Family: %s Qualifier: %s Value: %s", cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8()); } } } catch(ApiException e) { e.printStackTrace(); } }
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
ByteString |
Returns | |
---|---|
Type | Description |
Row |
readRow(String tableId, ByteString rowKey, Filters.Filter filter) (deprecated)
public Row readRow(String tableId, ByteString rowKey, Filters.Filter filter)
Deprecated. Please use BigtableDataClient#readRow(TargetId, ByteString, Filter) instead.
Convenience method for synchronously reading a single row. If the row does not exist, the value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Build the filter expression
Filter filter = FILTERS.chain()
.filter(FILTERS.qualifier().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
Row row = bigtableDataClient.readRow(tableId, ByteString.copyFromUtf8("key"), filter);
// Do something with row, for example, display all cells
if(row != null) {
System.out.println(row.getKey().toStringUtf8());
for(RowCell cell : row.getCells()) {
System.out.printf("Family: %s Qualifier: %s Value: %s", cell.getFamily(),
cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
}
}
} catch(ApiException e) {
e.printStackTrace();
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
ByteString |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
Row |
readRow(String tableId, String rowKey) (deprecated)
public Row readRow(String tableId, String rowKey)
Deprecated. Please use BigtableDataClient#readRow(TargetId, String) instead.
Convenience method for synchronously reading a single row. If the row does not exist, the value will be null.
Sample code:
{code try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) { String tableId = "[TABLE]";
Row row = bigtableDataClient.readRow(tableId, "key"); // Do something with row, for example, display all cells if(row != null) { System.out.println(row.getKey().toStringUtf8()); for(RowCell cell : row.getCells()) { System.out.printf("Family: %s Qualifier: %s Value: %s", cell.getFamily(), cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8()); } } } catch(ApiException e) { e.printStackTrace(); } }
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
String |
Returns | |
---|---|
Type | Description |
Row |
readRow(String tableId, String rowKey, Filters.Filter filter) (deprecated)
public Row readRow(String tableId, String rowKey, Filters.Filter filter)
Deprecated. Please use BigtableDataClient#readRow(TargetId, String, Filter) instead.
Convenience method for synchronously reading a single row. If the row does not exist, the value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Build the filter expression
Filter filter = FILTERS.chain()
.filter(FILTERS.qualifier().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
Row row = bigtableDataClient.readRow(tableId, "key", filter);
// Do something with row, for example, display all cells
if(row != null) {
System.out.println(row.getKey().toStringUtf8());
for(RowCell cell : row.getCells()) {
System.out.printf("Family: %s Qualifier: %s Value: %s", cell.getFamily(),
cell.getQualifier().toStringUtf8(), cell.getValue().toStringUtf8());
}
}
} catch(ApiException e) {
e.printStackTrace();
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
String |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
Row |
readRowAsync(TargetId targetId, ByteString rowKey)
public ApiFuture<Row> readRowAsync(TargetId targetId, ByteString rowKey)
Convenience method for asynchronously reading a single row on the specified TargetId. If the row does not exist, the future's value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ApiFuture<Row> futureResult = bigtableDataClient.readRowAsync(TableId.of(tableId), ByteString.copyFromUtf8("key"));
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row result) {
if (result != null) {
System.out.println("Got row: " + result);
}
}
}, MoreExecutors.directExecutor());
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
ByteString |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readRowAsync(TargetId targetId, ByteString rowKey, Filters.Filter filter)
public ApiFuture<Row> readRowAsync(TargetId targetId, ByteString rowKey, Filters.Filter filter)
Convenience method for asynchronously reading a single row on the specified TargetId. If the row does not exist, the value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Build the filter expression
Filters.Filter filter = FILTERS.chain()
.filter(FILTERS.qualifier().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
ApiFuture<Row> futureResult = bigtableDataClient.readRowAsync(TableId.of(tableId), ByteString.copyFromUtf8("key"), filter);
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row result) {
if (result != null) {
System.out.println("Got row: " + result);
}
}
}, MoreExecutors.directExecutor());
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
ByteString |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readRowAsync(TargetId targetId, String rowKey)
public ApiFuture<Row> readRowAsync(TargetId targetId, String rowKey)
Convenience method for asynchronously reading a single row on the specified TargetId. If the row does not exist, the future's value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ApiFuture<Row> futureResult = bigtableDataClient.readRowAsync(TableId.of(tableId), "key");
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row result) {
if (result != null) {
System.out.println("Got row: " + result);
}
}
}, MoreExecutors.directExecutor());
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
String |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readRowAsync(TargetId targetId, String rowKey, Filters.Filter filter)
public ApiFuture<Row> readRowAsync(TargetId targetId, String rowKey, Filters.Filter filter)
Convenience method for asynchronously reading a single row on the specified TargetId. If the row does not exist, the future's value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Build the filter expression
Filters.Filter filter = FILTERS.chain()
.filter(FILTERS.qualifier().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
ApiFuture<Row> futureResult = bigtableDataClient.readRowAsync(TableId.of(tableId), "key", filter);
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row result) {
if (result != null) {
System.out.println("Got row: " + result);
}
}
}, MoreExecutors.directExecutor());
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameters | |
---|---|
Name | Description |
targetId |
TargetId |
rowKey |
String |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readRowAsync(String tableId, ByteString rowKey) (deprecated)
public ApiFuture<Row> readRowAsync(String tableId, ByteString rowKey)
Deprecated. Please use BigtableDataClient#readRowAsync(TargetId, ByteString) instead.
Convenience method for asynchronously reading a single row. If the row does not exist, the future's value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ApiFuture<Row> futureResult = bigtableDataClient.readRowAsync(tableId, ByteString.copyFromUtf8("key"));
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row row) {
if (result != null) {
System.out.println("Got row: " + result);
}
}
}, MoreExecutors.directExecutor());
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
ByteString |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readRowAsync(String tableId, ByteString rowKey, Filters.Filter filter) (deprecated)
public ApiFuture<Row> readRowAsync(String tableId, ByteString rowKey, Filters.Filter filter)
Deprecated. Please use BigtableDataClient#readRowAsync(TargetId, ByteString, Filter) instead.
Convenience method for asynchronously reading a single row. If the row does not exist, the future's value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Build the filter expression
Filters.Filter filter = FILTERS.chain()
.filter(FILTERS.qualifier().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
ApiFuture<Row> futureResult = bigtableDataClient.readRowAsync(tableId, ByteString.copyFromUtf8("key"), filter);
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row row) {
if (result != null) {
System.out.println("Got row: " + result);
}
}
}, MoreExecutors.directExecutor());
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
ByteString |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readRowAsync(String tableId, String rowKey) (deprecated)
public ApiFuture<Row> readRowAsync(String tableId, String rowKey)
Deprecated. Please use BigtableDataClient#readRowAsync(TargetId, String) instead.
Convenience method for asynchronously reading a single row. If the row does not exist, the future's value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
ApiFuture<Row> futureResult = bigtableDataClient.readRowAsync(tableId, "key");
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row result) {
if (result != null) {
System.out.println("Got row: " + result);
}
}
}, MoreExecutors.directExecutor());
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
String |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readRowAsync(String tableId, String rowKey, Filters.Filter filter) (deprecated)
public ApiFuture<Row> readRowAsync(String tableId, String rowKey, Filters.Filter filter)
Deprecated. Please use BigtableDataClient#readRowAsync(TargetId, String, Filter) instead.
Convenience method for asynchronously reading a single row. If the row does not exist, the future's value will be null.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
// Build the filter expression
Filters.Filter filter = FILTERS.chain()
.filter(FILTERS.qualifier().regex("prefix.*"))
.filter(FILTERS.limit().cellsPerRow(10));
ApiFuture<Row> futureResult = bigtableDataClient.readRowAsync(tableId, "key", filter);
ApiFutures.addCallback(futureResult, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row row) {
if (result != null) {
System.out.println("Got row: " + result);
}
}
}, MoreExecutors.directExecutor());
}
Parameters | |
---|---|
Name | Description |
tableId |
String |
rowKey |
String |
filter |
Filters.Filter |
Returns | |
---|---|
Type | Description |
ApiFuture<Row> |
readRowCallable()
public UnaryCallable<Query,Row> readRowCallable()
Reads a single row. The returned callable object allows for customization of api invocation.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
Query query = Query.create(tableId)
.rowKey("[KEY]")
.filter(FILTERS.qualifier().regex("[COLUMN PREFIX].*"));
// Synchronous invocation
try {
Row row = bigtableDataClient.readRowCallable().call(query);
if (row == null) {
System.out.println("Row not found");
}
} catch (RuntimeException e) {
e.printStackTrace();
}
// Asynchronous invocation
ApiFuture<Row> rowFuture = bigtableDataClient.readRowCallable().futureCall(query);
ApiFutures.addCallback(rowFuture, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row row) {
if (row == null) {
System.out.println("Row not found");
}
}
}, MoreExecutors.directExecutor());
}
See Also: UnaryCallableFor call styles., com.google.cloud.bigtable.data.v2.models.FiltersFor the filter building DSL., QueryFor query options.
Returns | |
---|---|
Type | Description |
UnaryCallable<Query,Row> |
readRows(Query query)
public ServerStream<Row> readRows(Query query)
Convenience method for synchronously streaming the results of a Query. The returned ServerStream instance is not threadsafe, it can only be used from single thread.
Sample code:
// Import the filter DSL
import static com.google.cloud.bigtable.data.v2.models.Filters.FILTERS;
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
Query query = Query.create(tableId)
.range("[START KEY]", "[END KEY]")
.filter(FILTERS.qualifier().regex("[COLUMN PREFIX].*"));
try {
ServerStream<Row> stream = bigtableDataClient.readRows(query);
int count = 0;
// Iterator style
for (Row row : stream) {
if (++count > 10) {
stream.cancel();
break;
}
// Do something with row
}
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
}
See Also: com.google.cloud.bigtable.data.v2.models.FiltersFor the filter building DSL., ServerStreamingCallableFor call styles., QueryFor query options.
Parameter | |
---|---|
Name | Description |
query |
Query |
Returns | |
---|---|
Type | Description |
ServerStream<Row> |
readRowsAsync(Query query, ResponseObserver<Row> observer)
public void readRowsAsync(Query query, ResponseObserver<Row> observer)
Convenience method for asynchronously streaming the results of a Query.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
Query query = Query.create(tableId)
.range("[START KEY]", "[END KEY]")
.filter(FILTERS.qualifier().regex("[COLUMN PREFIX].*"));
bigtableDataClient.readRowsAsync(query, new ResponseObserver<Row>() {
StreamController controller;
int count = 0;
public void onStart(StreamController controller) {
this.controller = controller;
}
public void onResponse(Row row) {
if (++count > 10) {
controller.cancel();
return;
}
// Do something with Row
}
public void onError(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onComplete() {
// Handle stream completion
}
});
}
Parameters | |
---|---|
Name | Description |
query |
Query |
observer |
ResponseObserver<Row> |
readRowsCallable()
public ServerStreamingCallable<Query,Row> readRowsCallable()
Streams back the results of the query. The returned callable object allows for customization of api invocation.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE]";
Query query = Query.create(tableId)
.range("[START KEY]", "[END KEY]")
.filter(FILTERS.qualifier().regex("[COLUMN PREFIX].*"));
// Iterator style
try {
for(Row row : bigtableDataClient.readRowsCallable().call(query)) {
// Do something with row
}
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
// Sync style
try {
List<Row> rows = bigtableDataClient.readRowsCallable().all().call(query);
} catch (NotFoundException e) {
System.out.println("Tried to read a non-existent table");
} catch (RuntimeException e) {
e.printStackTrace();
}
// Point look up
ApiFuture<Row> rowFuture = bigtableDataClient.readRowsCallable().first().futureCall(query);
ApiFutures.addCallback(rowFuture, new ApiFutureCallback<Row>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to read a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(Row result) {
System.out.println("Got row: " + result);
}
}, MoreExecutors.directExecutor());
// etc
}
See Also: com.google.cloud.bigtable.data.v2.models.FiltersFor the filter building DSL., ServerStreamingCallableFor call styles., QueryFor query options.
Returns | |
---|---|
Type | Description |
ServerStreamingCallable<Query,Row> |
sampleRowKeys(TargetId targetId)
public List<KeyOffset> sampleRowKeys(TargetId targetId)
Convenience method to synchronously return a sample of row keys on the specified TargetId.
The returned row keys will delimit contiguous sections of the table of approximately equal size, which can be used to break up the data for distributed tasks like mapreduces.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE_ID]";
List<KeyOffset> keyOffsets = bigtableDataClient.sampleRowKeys(TableId.of(tableId));
for(KeyOffset keyOffset : keyOffsets) {
// Do something with keyOffset
}
} catch(ApiException e) {
e.printStackTrace();
}
Parameter | |
---|---|
Name | Description |
targetId |
TargetId |
Returns | |
---|---|
Type | Description |
List<KeyOffset> |
sampleRowKeys(String tableId) (deprecated)
public List<KeyOffset> sampleRowKeys(String tableId)
Deprecated. Please use BigtableDataClient#sampleRowKeys(TargetId) instead.
Convenience method to synchronously return a sample of row keys in the table. The returned row keys will delimit contiguous sections of the table of approximately equal size, which can be used to break up the data for distributed tasks like mapreduces.
Sample code:
try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE_ID]";
List<KeyOffset> keyOffsets = bigtableDataClient.sampleRowKeys(tableId);
for(KeyOffset keyOffset : keyOffsets) {
// Do something with keyOffset
}
} catch(ApiException e) {
e.printStackTrace();
}
Parameter | |
---|---|
Name | Description |
tableId |
String |
Returns | |
---|---|
Type | Description |
List<KeyOffset> |
sampleRowKeysAsync(TargetId targetId)
public ApiFuture<List<KeyOffset>> sampleRowKeysAsync(TargetId targetId)
Convenience method to asynchronously return a sample of row keys on the specified TargetId.
The returned row keys will delimit contiguous sections of the table of approximately equal size, which can be used to break up the data for distributed tasks like mapreduces.
Sample code:
try (BigtableClient bigtableDataClient = BigtableClient.create("[PROJECT]", "[INSTANCE]")) {
String tableId = "[TABLE_ID]";
ApiFuture<List<KeyOffset>> keyOffsetsFuture = bigtableClient.sampleRowKeysAsync(TableId.of(tableId));
ApiFutures.addCallback(keyOffsetsFuture, new ApiFutureCallback<List<KeyOffset>>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.out.println("Tried to sample keys of a non-existent table");
} else {
t.printStackTrace();
}
}
public void onSuccess(List<KeyOffset> keyOffsets) {
System.out.println("Got key offsets: " + keyOffsets);
}
}, MoreExecutors.directExecutor());
}
See Also: TableId, com.google.cloud.bigtable.data.v2.models.AuthorizedViewId
Parameter | |
---|---|
Name | Description |
targetId |
TargetId |
Returns | |
---|---|
Type | Description |
ApiFuture<List<KeyOffset>> |
sampleRowKeysAsync(String tableId) (deprecated)
public ApiFuture<List<KeyOffset>> sampleRowKeysAsync(String tableId)
Deprecated. Please use BigtableDataClient#sampleRowKeysAsync(TargetId) instead.
Convenience method to asynchronously return a sample of row keys in the table. The returned row keys will delimit contiguous sections of the table of approximately equal size, which can be used to break up the data for distributed tasks like mapreduces.
Sample code:
try (BigtableClient bigtableDataClient = BigtableClient.create("[PROJECT]", "[INSTANCE]")) {
ApiFuture<List<KeyOffset>> keyOffsetsFuture = bigtableClient.sampleRowKeysAsync("[TABLE]");
ApiFutures.addCallback(keyOffsetsFuture, new ApiFutureCallback<List<KeyOffset>>() {
public void onFailure(Throwable t) {
if (t instanceof NotFoundException) {
System.