bigtable 0.6.0 - Docs.rs

rust-bigtable [docs]

Rust library for working with Google Bigtable Data API

Supported API Methods

Full coverage of the Bigtable Data API v2:

Method	Description
`ReadRows`	Streams back the contents of all requested rows
`SampleRowKeys`	Returns a sample of row keys in the table
`MutateRow`	Mutates a row atomically
`MutateRows`	Mutates multiple rows in a batch
`CheckAndMutateRow`	Mutates a row atomically based on output of a predicate filter
`ReadModifyWriteRow`	Modifies a row atomically on the server
`PingAndWarm`	Warms up connection channels to the service
`GenerateInitialChangeStreamPartitions`	Generates initial change stream partitions
`ReadChangeStream`	Reads changes from a table's change stream
`PrepareQuery`	Prepares a GoogleSQL query for execution
`ExecuteQuery`	Executes a GoogleSQL query against a Bigtable table

How It Works

Requests are protobuf messages generated from Google's proto definitions. These messages are converted to JSON and sent to the predefined REST endpoints. Responses are returned as serde_json::Value.

Authentication is handled via goauth with JWT tokens.

Installation

[dependencies]
bigtable = "0.6"

Configuration

Provide service account credentials from Google Cloud Console as a JSON key file:

use bigtable::utils::get_auth_token;

let token = get_auth_token("service-account-key.json", true)?;

Usage

High-Level Wrappers

Simple wrappers for common operations:

use bigtable::utils::get_auth_token;
use bigtable::wraps;
use bigtable::support::Table;

// Read rows with limit
let token = get_auth_token("credentials.json", true)?;
let table = Table::default();
let rows = wraps::read_rows(&table, &token, Some(100))?;

// Bulk write rows (uses MutateRows - higher throughput)
let mut rows = vec![wraps::Row::default()];
wraps::bulk_write_rows(&mut rows, &token, table.clone())?;

// Write rows one at a time (uses ReadModifyWriteRow)
let mut rows = vec![wraps::Row::default()];
wraps::write_rows(&mut rows, &token, &table)?;

Direct API Access

For full control, use the request builder directly:

use bigtable::request::BTRequest;
use bigtable::method::{BigTable, ReadRows, MutateRow};
use bigtable::utils::{get_auth_token, encode_str};
use bigtable::protos::data::{Mutation, mutation};

let token = get_auth_token("credentials.json", true)?;

// ReadRows
let mut req = BTRequest {
    base: None,
    table: Default::default(),
    method: ReadRows::new(),
};
req.method.payload_mut().rows_limit = 10;
let response = req.execute(&token)?;

// MutateRow with SetCell
let mut req = BTRequest {
    base: None,
    table: Default::default(),
    method: MutateRow::new(),
};

let mut set_cell = mutation::SetCell::new();
set_cell.family_name = String::from("cf1");
set_cell.column_qualifier = encode_str("col1");
set_cell.timestamp_micros = -1;
set_cell.value = encode_str("value1");

let mut m = Mutation::new();
m.mutation = Some(mutation::Mutation::SetCell(set_cell));

req.method.payload_mut().row_key = encode_str("row1");
req.method.payload_mut().mutations.push(m);

let response = req.execute(&token)?;

Testing

Integration tests run against a live Bigtable instance:

# Run integration tests (requires credentials)
cargo test --test integration_tests -- --ignored --test-threads=1

# Run doc tests
cargo test

Dependencies

protobuf / protobuf-json-mapping - Protocol buffer handling and JSON conversion
goauth / smpl_jwt - Google OAuth2 / JWT authentication
curl - HTTP client
serde_json - JSON serialization

License

MIT