Struct Read 

pub struct Read { /* private fields */ }

Implements a client for the BigQuery Storage API.

Example

async fn sample(
) -> anyhow::Result<()> {
    let client = Read::builder().build().await?;
    let response = client.create_read_session()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

Service Description

BigQuery Read API.

The Read API can be used to read data from BigQuery.

Configuration

To configure Read use the with_* methods in the type returned by builder(). The default configuration should work for most applications. Common configuration changes include

• with_endpoint(): by default this client uses the global default endpoint (https://bigquerystorage.googleapis.com). Applications using regional endpoints or running in restricted networks (e.g. a network configured with Private Google Access with VPC Service Controls) may want to override this default.
• with_credentials(): by default this client uses Application Default Credentials. Applications using custom authentication may need to override this default.

Pooling and Cloning

Read holds a connection pool internally, it is advised to create one and reuse it. You do not need to wrap Read in an Rc or Arc to reuse it, because it already uses an Arc internally.

Implementations

impl Read

pub fn builder() -> ClientBuilder

Returns a builder for Read.

let client = Read::builder().build().await?;

pub fn from_stub<T>(stub: impl Into<Arc<T>>) -> Self

where T: Read + 'static,

Creates a new client from the provided stub.

The most common case for calling this function is in tests mocking the client’s behavior.

pub fn create_read_session(&self) -> CreateReadSession

Creates a new read session. A read session divides the contents of a BigQuery table into one or more streams, which can then be used to read data from the table. The read session also specifies properties of the data to be read, such as a list of columns or a push-down filter describing the rows to be returned.

A particular row can be read by at most one stream. When the caller has reached the end of each stream in the session, then all the data in the table has been read.

Data is assigned to each stream such that roughly the same number of rows can be read from each stream. Because the server-side unit for assigning data is collections of rows, the API does not guarantee that each stream will return the same number or rows. Additionally, the limits are enforced based on the number of pre-filtered rows, so some filters can lead to lopsided assignments.

Read sessions automatically expire 6 hours after they are created and do not require manual clean-up by the caller.

Example

use google_cloud_bigquery::Result;
async fn sample(
   client: &Read
) -> Result<()> {
    let response = client.create_read_session()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

pub fn read_rows(&self) -> ReadRows

Reads rows from the stream in the format prescribed by the ReadSession. Each response contains one or more table rows, up to a maximum of 128 MB per response; read requests which attempt to read individual rows larger than 128 MB will fail.

Each request also returns a set of stream statistics reflecting the current state of the stream.

Example

use google_cloud_bigquery::Result;
async fn sample(
   client: &Read
) -> Result<()> {
    let mut resp_stream = client.read_rows()
        /* set fields */
        .send().await?;
    while let Some(response) = resp_stream.next().await {
        let response = response?;
        println!("response {:?}", response);
    }
    Ok(())
}

pub fn split_read_stream(&self) -> SplitReadStream

Splits a given ReadStream into two ReadStream objects. These ReadStream objects are referred to as the primary and the residual streams of the split. The original ReadStream can still be read from in the same manner as before. Both of the returned ReadStream objects can also be read from, and the rows returned by both child streams will be the same as the rows read from the original stream.

Moreover, the two child streams will be allocated back-to-back in the original ReadStream. Concretely, it is guaranteed that for streams original, primary, and residual, that original[0-j] = primary[0-j] and original[j-n] = residual[0-m] once the streams have been read to completion.

Example

use google_cloud_bigquery::Result;
async fn sample(
   client: &Read
) -> Result<()> {
    let response = client.split_read_stream()
        /* set fields */
        .send().await?;
    println!("response {:?}", response);
    Ok(())
}

Trait Implementations

impl Clone for Read

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Read

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.