Package
@google-cloud/bigtable
Examples
Create a client that uses Application Default Credentials (ADC):
const {Bigtable} = require('@google-cloud/bigtable');
const bigtable = new Bigtable();
Create a client with explicit credentials:
const {Bigtable} = require('@google-cloud/bigtable');
const bigtable = new Bigtable({
projectId: 'your-project-id',
keyFilename: '/path/to/keyfile.json'
});
The Bigtable Emulator
// Make sure you have the {@link https://cloud.google.com/sdk/downloads gcloud SDK installed}, then run:
$ gcloud beta emulators bigtable start
// Before running your Node.js app, set the environment variables that this
// library will look for to connect to the emulator:
$ $(gcloud beta emulators bigtable env-init)
Creating a Bigtable Instance and Cluster
// Before you create your table, you first need to create a Bigtable Instance
// and cluster for the table to be served from.
const {Bigtable} = require('@google-cloud/bigtable');
const bigtable = new Bigtable();
const callback = (err, instance, operation) => {
operation
.on('error', console.log)
.on('complete', () => {
// `instance` is your newly created Instance object.
});
};
const instance = bigtable.instance('my-instance');
instance.create({
clusters: [
{
id: 'my-cluster',
location: 'us-central1-b',
nodes: 3
}
]
}, callback);
// This can also be done from either the Google Cloud Platform Console or the
// `gcloud` cli tool. Please refer to the
// {@link https://cloud.google.com/bigtable/docs/creating-instance official Bigtable documentation}
// for more information.
Creating Tables
// After creating your instance and enabling the Bigtable APIs, you are now
// ready to create your table with {@link Instance#createTable}.
instance.createTable('prezzy', function(err, table) {
// `table` is your newly created Table object.
});
Creating Column Families
// Column families are used to group together various pieces of data within
// your table. You can think of column families as a mechanism to categorize
// all of your data.
//
// We can create a column family with {@link Table#createFamily}.
const table = instance.table('prezzy');
table.createFamily('follows', function(err, family) {
// `family` is your newly created Family object.
});
// It is also possible to create your column families when creating a new
// table.
const options = {
families: ['follows']
};
instance.createTable('prezzy', options, function(err, table) {});
Creating Rows
// New rows can be created within your table using
// {@link Table#insert}. You must provide a unique key for each row
// to be inserted, this key can then be used to retrieve your row at a later
// time.
//
// With Bigtable, all columns have a unique id composed of a column family
// and a column qualifier. In the example below `follows` is the column
// family and `tjefferson` is the column qualifier. Together they could be
// referred to as `follows:tjefferson`.
const rows = [
{
key: 'wmckinley',
data: {
follows: {
tjefferson: 1
}
}
}
];
table.insert(rows, err => {
if (!err) {
// Your rows were successfully inserted.
}
});
Retrieving Rows
// If you're anticipating a large number of rows to be returned, we suggest
// using the {@link Table#getRows} streaming API.
table.createReadStream()
.on('error', console.error)
.on('data', row => {
// `row` is a Row object.
});
// If you're not anticpating a large number of results, a callback mode
// is also available.
const callback = (err, rows) => {
// `rows` is an array of Row objects.
};
table.getRows(callback);
// A range of rows can be retrieved by providing `start` and `end` row keys.
const options = {
start: 'gwashington',
end: 'wmckinley'
};
table.getRows(options, callback);
// Retrieve an individual row with {@link Row#get}.
const row = table.row('alincoln');
row.get(err => {
// `row.data` is now populated.
});
Accessing Row Data
// When retrieving rows, upon success the `row.data` property will be
// populated by an object. That object will contain additional objects
// for each family in your table that the row has data for.
//
// By default, when retrieving rows, each column qualifier will provide you
// with all previous versions of the data. So your `row.data` object could
// resemble the following.
{
follows: {
wmckinley: [
{
value: 1,
timestamp: 1466017315951
}, {
value: 2,
timestamp: 1458619200000
}
]
}
}
// The `timestamp` field can be used to order cells from newest to oldest.
// If you only wish to retrieve the most recent version of the data, you
// can specify the number of cells with a {@link Filter} object.
const filter = [
{
column: {
cellLimit: 1
}
}
];
table.getRows({
filter: filter
}, callback);
Deleting Row Data
// We can delete all of an individual row's cells using {@link Row#delete}.
const callback = err => {
if (!err) {
// All cells for this row were deleted successfully.
}
};
row.delete(callback);
// To delete a specific set of cells, we can provide an array of
// column families and qualifiers.
const cells = [
'follows:gwashington',
'traits'
];
row.delete(cells, callback);
Deleting Rows
// If you wish to delete multiple rows entirely, we can do so with
// {@link Table#deleteRows}. You can provide this method with a
// row key prefix.
const options = {
prefix: 'gwash'
};
table.deleteRows(options, err => {
if (!err) {
// Rows were deleted successfully.
}
});
// If you omit the prefix, you can delete all rows in your table.
table.deleteRows(err => {
if (!err) {
// All rows were deleted successfully.
}
});
Constructors
(constructor)(options)
constructor(options?: BigtableOptions);
Constructs a new instance of the Bigtable class
Properties
api
api: {
[index: string]: v2.BigtableClient | v2.BigtableInstanceAdminClient | v2.BigtableTableAdminClient;
};
AppProfile
static AppProfile: AppProfile;
appProfileId
auth
Cluster
customEndpoint
Instance
static Instance: Instance;
options
options: BigtableOptions;
projectId
projectName
shouldReplaceProjectIdToken
shouldReplaceProjectIdToken: boolean;
Methods
close()
close(): Promise<void[]>;
Close all bigtable clients. New requests will be rejected but it will not kill connections with pending requests.
| Returns |
|---|
| Type | Description |
Promise<void[]> | |
createInstance(id, options)
createInstance(id: string, options: InstanceOptions): Promise<CreateInstanceResponse>;
createInstance(id, options, callback)
createInstance(id: string, options: InstanceOptions, callback: CreateInstanceCallback): void;
| Returns |
|---|
| Type | Description |
void | |
getInstances(gaxOptions)
getInstances(gaxOptions?: CallOptions): Promise<GetInstancesResponse>;
| Parameter |
|---|
| Name | Description |
gaxOptions |
CallOptions
|
getInstances(callback)
getInstances(callback: GetInstancesCallback): void;
| Returns |
|---|
| Type | Description |
void | |
getInstances(gaxOptions, callback)
getInstances(gaxOptions: CallOptions, callback: GetInstancesCallback): void;
| Returns |
|---|
| Type | Description |
void | |
getProjectId_(callback)
getProjectId_(callback: (err: Error | null, projectId?: string) => void): void;
Determine and localize the project ID. If a user provides an ID, we bypass checking with the auth client for an ID.
| Parameter |
|---|
| Name | Description |
callback |
(err: Error | null, projectId?: string) => void
Callback function.
|
| Returns |
|---|
| Type | Description |
void | |
instance(name)
instance(name: string): Instance;
Get a reference to a Cloud Bigtable instance.
| Parameter |
|---|
| Name | Description |
name |
string
|
| Returns |
|---|
| Type | Description |
Instance | {Instance}
|
request(config)
request<T = any>(config?: any): AbortableDuplex;
| Parameter |
|---|
| Name | Description |
config |
any
|
| Type Parameter |
|---|
| Name | Description |
T | |
request(config, callback)
request<T = any>(config?: any, callback?: RequestCallback<T>): void;
| Returns |
|---|
| Type | Description |
void | |
| Type Parameter |
|---|
| Name | Description |
T | |
