Struct google_cloud_spanner::transaction_ro::ReadOnlyTransaction

pub struct ReadOnlyTransaction {
    pub rts: Option<OffsetDateTime>,
    /* private fields */
}

ReadOnlyTransaction provides a snapshot transaction with guaranteed consistency across reads, but does not allow writes. Read-only transactions can be configured to read at timestamps in the past.

Read-only transactions do not take locks. Instead, they work by choosing a Cloud Spanner timestamp, then executing all reads at that timestamp. Since they do not acquire locks, they do not block concurrent read-write transactions.

Unlike locking read-write transactions, read-only transactions never abort. They can fail if the chosen read timestamp is garbage collected; however, the default garbage collection policy is generous enough that most applications do not need to worry about this in practice. See the documentation of TimestampBound for more details.

Fields

rts: Option<OffsetDateTime>

Implementations

impl ReadOnlyTransaction

pub async fn single( session: ManagedSession, tb: TimestampBound ) -> Result<ReadOnlyTransaction, Status>

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

begin starts a snapshot read-only Transaction on Cloud Spanner.

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.

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, Error};
use google_cloud_spanner::reader::AsyncIterator;

#[tokio::main]
async fn run(client: Client) -> Result<(), Error> {
    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.

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;
use google_cloud_spanner::client::Error;

async fn run(client: Client) -> Result<(), Error> {
    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.

Trait Implementations

impl Deref for ReadOnlyTransaction

type Target = Transaction

The resulting type after dereferencing.

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

Dereferences the value.

impl DerefMut for ReadOnlyTransaction

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

Mutably dereferences the value.