Struct google_cloud_spanner::transaction::Transaction

pub struct Transaction { /* private fields */ }

Implementations

impl 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
    }