Struct google_cloud_spanner::transaction_ro::BatchReadOnlyTransaction

pub struct BatchReadOnlyTransaction { /* private fields */ }

BatchReadOnlyTransaction is a ReadOnlyTransaction that allows for exporting arbitrarily large amounts of data from Cloud Spanner databases. BatchReadOnlyTransaction partitions a read/query request. Read/query request can then be executed independently over each partition while observing the same snapshot of the database.

Implementations

impl BatchReadOnlyTransaction

pub async fn begin(
    session: ManagedSession,
    tb: TimestampBound,
    options: CallOptions
) -> Result<BatchReadOnlyTransaction, Status>

Examples found in repository

src/client.rs (line 308)

    pub async fn batch_read_only_transaction_with_option(
        &self,
        options: ReadOnlyTransactionOption,
    ) -> Result<BatchReadOnlyTransaction, TxError> {
        let session = self.get_session().await?;
        let result = BatchReadOnlyTransaction::begin(session, options.timestamp_bound, options.call_options).await?;
        Ok(result)
    }

pub async fn partition_read(
    &mut self,
    table: &str,
    columns: &[&str],
    keys: impl Into<KeySet> + Clone
) -> Result<Vec<Partition<TableReader>>, Status>

partition_read returns a list of Partitions that can be used to read rows from the database. These partitions can be executed across multiple processes, even across different machines. The partition size and count hints can be configured using PartitionOptions.

pub async fn partition_read_with_option(
    &mut self,
    table: &str,
    columns: &[&str],
    keys: impl Into<KeySet> + Clone,
    po: Option<PartitionOptions>,
    ro: ReadOptions
) -> Result<Vec<Partition<TableReader>>, Status>

partition_read returns a list of Partitions that can be used to read rows from the database. These partitions can be executed across multiple processes, even across different machines. The partition size and count hints can be configured using PartitionOptions.

Examples found in repository

src/transaction_ro.rs (line 154)

    pub async fn partition_read(
        &mut self,
        table: &str,
        columns: &[&str],
        keys: impl Into<KeySet> + Clone,
    ) -> Result<Vec<Partition<TableReader>>, Status> {
        self.partition_read_with_option(table, columns, keys, None, ReadOptions::default())
            .await
    }

pub async fn partition_query(
    &mut self,
    stmt: Statement
) -> Result<Vec<Partition<StatementReader>>, Status>

partition_query returns a list of Partitions that can be used to execute a query against the database.

pub async fn partition_query_with_option(
    &mut self,
    stmt: Statement,
    po: Option<PartitionOptions>,
    qo: QueryOptions
) -> Result<Vec<Partition<StatementReader>>, Status>

partition_query returns a list of Partitions that can be used to execute a query against the database.

Examples found in repository

src/transaction_ro.rs (line 215)

    pub async fn partition_query(&mut self, stmt: Statement) -> Result<Vec<Partition<StatementReader>>, Status> {
        self.partition_query_with_option(stmt, None, QueryOptions::default())
            .await
    }

pub async fn execute<T: Reader + Sync + Send + 'static>(
    &mut self,
    partition: Partition<T>,
    option: Option<CallOptions>
) -> Result<RowIterator<'_>, Status>

execute runs a single Partition obtained from partition_read or partition_query.

Methods from Deref<Target = Transaction>

pub async fn query(
    &mut self,
    statement: Statement
) -> Result<RowIterator<'_>, Status>

query executes a query against the database. It returns a RowIterator for retrieving the resulting rows.

query returns only row data, without a query plan or execution statistics.

pub async fn query_with_option(
    &mut self,
    statement: Statement,
    options: QueryOptions
) -> Result<RowIterator<'_>, Status>

query executes a query against the database. It returns a RowIterator for retrieving the resulting rows.

query returns only row data, without a query plan or execution statistics.

Examples found in repository

src/transaction.rs (line 90)

    pub async fn query(&mut self, statement: Statement) -> Result<RowIterator<'_>, Status> {
        self.query_with_option(statement, QueryOptions::default()).await
    }

pub async fn read(
    &mut self,
    table: &str,
    columns: &[&str],
    key_set: impl Into<KeySet>
) -> Result<RowIterator<'_>, Status>

read returns a RowIterator for reading multiple rows from the database.

use google_cloud_spanner::key::Key;
use google_cloud_spanner::client::Client;
use google_cloud_spanner::reader::AsyncIterator;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    const DATABASE: &str = "projects/local-project/instances/test-instance/databases/local-database";
    let client = Client::new(DATABASE).await?;

    let mut tx = client.single().await?;
    let mut iter = tx.read("Guild", &["GuildID", "OwnerUserID"], vec![
        Key::new(&"pk1"),
        Key::new(&"pk2")
    ]).await?;

    while let Some(row) = iter.next().await? {
        let guild_id = row.column_by_name::<String>("GuildID");
        //do something
    };
    Ok(())
}

pub async fn read_with_option(
    &mut self,
    table: &str,
    columns: &[&str],
    key_set: impl Into<KeySet>,
    options: ReadOptions
) -> Result<RowIterator<'_>, Status>

read returns a RowIterator for reading multiple rows from the database.

Examples found in repository

src/transaction.rs (line 152)

    pub async fn read(
        &mut self,
        table: &str,
        columns: &[&str],
        key_set: impl Into<KeySet>,
    ) -> Result<RowIterator<'_>, Status> {
        self.read_with_option(table, columns, key_set, ReadOptions::default())
            .await
    }

    /// read returns a RowIterator for reading multiple rows from the database.
    pub async fn read_with_option(
        &mut self,
        table: &str,
        columns: &[&str],
        key_set: impl Into<KeySet>,
        options: ReadOptions,
    ) -> Result<RowIterator<'_>, Status> {
        let request = ReadRequest {
            session: self.get_session_name(),
            transaction: Some(self.transaction_selector.clone()),
            table: table.to_string(),
            index: options.index,
            columns: columns.iter().map(|x| x.to_string()).collect(),
            key_set: Some(key_set.into().inner),
            limit: options.limit,
            resume_token: vec![],
            partition_token: vec![],
            request_options: Transaction::create_request_options(options.call_options.priority),
        };

        let session = self.as_mut_session();
        let reader = Box::new(TableReader { request });
        RowIterator::new(session, reader, Some(options.call_options)).await
    }

    /// read returns a RowIterator for reading multiple rows from the database.
    /// ```
    /// use google_cloud_spanner::key::Key;
    /// use google_cloud_spanner::client::Client;
    ///
    /// #[tokio::main]
    /// async fn main() -> Result<(), anyhow::Error> {
    ///     const DATABASE: &str = "projects/local-project/instances/test-instance/databases/local-database";
    ///     let client = Client::new(DATABASE).await?;
    ///     let mut tx = client.single().await?;
    ///     let row = tx.read_row("Guild", &["GuildID", "OwnerUserID"], Key::new(&"guild1")).await?;
    ///     Ok(())
    /// }
    /// ```
    pub async fn read_row(&mut self, table: &str, columns: &[&str], key: Key) -> Result<Option<Row>, Status> {
        self.read_row_with_option(table, columns, key, ReadOptions::default())
            .await
    }

    /// read returns a RowIterator for reading multiple rows from the database.
    pub async fn read_row_with_option(
        &mut self,
        table: &str,
        columns: &[&str],
        key: Key,
        options: ReadOptions,
    ) -> Result<Option<Row>, Status> {
        let call_options = options.call_options.clone();
        let mut reader = self
            .read_with_option(table, columns, KeySet::from(key), options)
            .await?;
        reader.set_call_options(call_options);
        reader.next().await
    }

pub async fn read_row(
    &mut self,
    table: &str,
    columns: &[&str],
    key: Key
) -> Result<Option<Row>, Status>

read returns a RowIterator for reading multiple rows from the database.

use google_cloud_spanner::key::Key;
use google_cloud_spanner::client::Client;

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    const DATABASE: &str = "projects/local-project/instances/test-instance/databases/local-database";
    let client = Client::new(DATABASE).await?;
    let mut tx = client.single().await?;
    let row = tx.read_row("Guild", &["GuildID", "OwnerUserID"], Key::new(&"guild1")).await?;
    Ok(())
}

pub async fn read_row_with_option(
    &mut self,
    table: &str,
    columns: &[&str],
    key: Key,
    options: ReadOptions
) -> Result<Option<Row>, Status>

read returns a RowIterator for reading multiple rows from the database.

Examples found in repository

src/transaction.rs (line 197)

    pub async fn read_row(&mut self, table: &str, columns: &[&str], key: Key) -> Result<Option<Row>, Status> {
        self.read_row_with_option(table, columns, key, ReadOptions::default())
            .await
    }

Trait Implementations

impl Deref for BatchReadOnlyTransaction

type Target = ReadOnlyTransaction

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for BatchReadOnlyTransaction

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.