Class BigtableDataClient (2.46.0)

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());

Inheritance

java.lang.Object > BigtableDataClient

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)

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();
 }

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();
 }

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());
 }

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());
 }

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.
 }

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.
 }

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.

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();
 }

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.

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();
 }

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.

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();
 }

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.

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.

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.

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();
 }

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();
 }

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();
 }

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();
 }

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());
 }

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());
 }

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());
 }

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());
 }

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());
 }

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.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());
 }

Parameter
Name	Description
`tableId`	`String`

Returns
Type	Description
`ApiFuture<List<KeyOffset>>`

sampleRowKeysCallable() (deprecated)

public UnaryCallable<String,List<KeyOffset>> sampleRowKeysCallable()

Deprecated. Please use BigtableDataClient#sampleRowKeysCallableWithRequest() instead.

Returns 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. The returned callable object allows for customization of api invocation.

Sample code:


 try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
   // Synchronous invocation
   try {
     List<KeyOffset> keyOffsets = bigtableDataClient.sampleRowKeysCallable().call("[TABLE]");
   } catch (NotFoundException e) {
     System.out.println("Tried to sample keys of a non-existent table");
   } catch (RuntimeException e) {
     e.printStackTrace();
   }

   // Asynchronous invocation
   ApiFuture<List<KeyOffset>> keyOffsetsFuture = bigtableDataClient.sampleRowKeysCallable().futureCall("[TABLE]");

   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());
 }

Returns
Type	Description
`UnaryCallable<String,List<KeyOffset>>`

sampleRowKeysCallableWithRequest()

public UnaryCallable<SampleRowKeysRequest,List<KeyOffset>> sampleRowKeysCallableWithRequest()

Returns a sample of row keys in the table. This callable allows takes a SampleRowKeysRequest object rather than a String input, and thus can be used to sample against a 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. The returned callable object allows for customization of api invocation.

Sample code:


 try (BigtableDataClient bigtableDataClient = BigtableDataClient.create("[PROJECT]", "[INSTANCE]")) {
   SampleRowKeysRequest sampleRowKeys = SampleRowKeysRequest.create(TableId.of("[TABLE]"));
   // Synchronous invocation
   try {
     List<KeyOffset> keyOffsets = bigtableDataClient.sampleRowKeysCallableWithRequest().call(sampleRowKeys);
   } catch (NotFoundException e) {
     System.out.println("Tried to sample keys of a non-existent table");
   } catch (RuntimeException e) {
     e.printStackTrace();
   }

   // Asynchronous invocation
   ApiFuture<List<KeyOffset>> keyOffsetsFuture = bigtableDataClient.sampleRowKeysCallableWithRequest().futureCall(sampleRowKeys);

   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());
 }

Returns
Type	Description
`UnaryCallable<SampleRowKeysRequest,List<KeyOffset>>`