bigtable.md

BigTable

var bigtable = gcloud.bigtable();

getZones

bigtable.getZones(function(err, zones, apiResponse) {});

Zone

---

getClusters

var zone = bigtable.zone('my-zone');

zone.getClusters(function(err, clusters, apiResponse) {});

Create a cluster

zone.createCluster(clusterOptions, function(err, cluster, apiResponse) {});

Cluster

---

Get Cluster Metadata

cluster.getMetadata(function (err, metadata, apiResponse) {});

Update Cluster Metadata

cluster.setMetadata(metaData, function(err, metadata, apiResponse) {});

Delete Cluster

cluster.delete(function (err, apiResponse) {});

Undelete Cluster

cluster.restore(function (err, apiResponse) {});

Create a Table

cluster.createTable('my-table', function(err, table, apiResponse) {});
// or
cluster.createTable(tableOptions, function(err, table, apiResponse) {});

Get Prexisting Table (half initialized)

var myTable = cluster.table('my-table');

Get All Tables on Cluster

cluster.getTables(function (err, tables, apiResponse) {});

Table

---

Get Table Schema

table.getMetadata(function (err, tableSchema, apiResponse) {});

Delete a Table

table.delete(function (err, table, apiResponse) {});

Rename a Table

table.rename('awesome-table', function (err, table, apiResponse) {});

Create a Column Family

table.createFamily('user', function (err, family, apiResponse) {});

Get Pre-existing Family (half initialized)

var userFamily = table.family('user');

Update a Family

userFamily.setMetadata(metaData, function(err, family, apiResponse) {});

Delete a Family

userFamily.delete(function(err, apiResponse) {});

Get Sample Keys

If a callback is not provided a stream will be returned

table.getSampleKeys(function (err, keys, apiResponse) {});

Get Table Rows

If callback is not provided a stream is returned

var rowOptions = {
  prefix: 'com.google.'
};

table.getRows(rowOptions, function(err, rows, apiResponse) {});

Delete Table Rows

rowOptions would be filters used to determine which rows to delete

table.deleteRows(rowOptions, function(err, apiResponse) {});

Create a Row

table.createRow(rowData, function(err, row, apiResponse) {});

Create Multiple Rows

table.createRows([rowData], function(err, rows, apiResponse) {});

Get Specific Row (half initialized)

var myRow = table.row('my-row');

Update a Row

myRow.set('user:name', 'stephen', function(err, row, apiResponse) {});

// or for multiple columns
var rowData = {
  user: { // family
    name: 'stephen', // column
    age: 99 // column
  }
};
myRow.set(rowData, function(err, row, apiResponse) {});

Get Columns From Row

myRow.get(['user:name'], function(err, columns, apiResponse) {});

Delete Columns From Row

myRow.delete(['user:name'], function(err, columns, apiResponse) {});

Delete An Entire Row

myRow.delete(function(err, columns, apiResponse) {});

Target Specific Family From Row

This should not be confused with the Table#family which allows you to update/delete families for the entire Table.

var myFamily = myRow.family('user');

// get column
myFamily.get('name', function(err, name, apiResponse) {});

// set column(s)
myFamily.set('name', 'peter', function(err, family, apiResponse) {});
// or
myFamily.set({ name: 'peter' }, function (err, family, apiResponse) {});

// delete column(s)
myFamily.delete(['name'], function(err, family, apiResponse) {});

// delete all columns associated with family
myFamily.delete(function(err, apiResponse) {});

var bigtable = gcloud.bigtable({
  zone: 'my-zone',
  cluster: 'my-cluster'
});

var myTable = bigtable.table('my-table');
var myOtherTable = bigtable.table('my-othertable');

// vs.

var bigtable = gcloud.bigtable();

var myTable = bigtable
  .zone('my-zone')
  .cluster('my-cluster')
  .table('my-table');

I still choose the second personally. I see the convenience in the first, but it doesn't follow suit with our other APIs, which could be confusing:

var gcs = gcloud.storage({
  bucket: 'my-cool-bucket'
});

gcs.getFiles();

We could try to go back over our APIs to support a similar pattern, but even looking at the example above, I'm not sure it's preferred. More specifically, .bigtable() should return a reference to a Bigtable object, and .storage() should return a reference to a Storage object. "gcs.getFiles()" would mean "get all the files from GCS" and "bigtable.table()" (from your example) would mean "get this table from bigtable". The solution to that is obviously naming the vars differently:

var cluster = gcloud.bigtable({
  zone: 'my-zone',
  cluster: 'my-cluster'
});

var myTable = cluster.table('my-table');
var myOtherTable = cluster.table('my-othertable');

// and...

var bucket = gcloud.storage({
  bucket: 'my-cool-bucket'
});

bucket.getFiles();

And with those name changes, we have perspective for how they're supposed to behave. But, it's unexpected to get a cluster back from "gcloud.bigtable" and a bucket back from "gcloud.storage" directly. Having them act as a child class is misleading to their "parent-scope" capabilities.

Does an endpoint exist for this, or do we parse out a part of the response from the resource (i.e. what would come back from getMetadata)?

There's a GetTable rpc defined and the comments around it state that it returns the schema of the table.

I think that would just be table.getMetadata() then.

That's cool with me, I just thought I'd throw it out there. 😄