Struct Partition 

pub struct Partition { /* private fields */ }

Defines the segments of data to be read in a partitioned read or query. These partitions can be serialized and processed across several different machines or processes.

Implementations

impl Partition

pub fn set_data_boost(self, enabled: bool) -> Self

Sets whether Data Boost is enabled for this partition.

Example

// On a worker receiving a partition, execute it with Data Boost:
let mut result_set = partitions[0].clone()
    .set_data_boost(true)
    .execute(&db_client)
    .await?;

pub fn with_attempt_timeout(self, timeout: Duration) -> Self

Sets the per-attempt timeout for this partition execution.

Note: This field is not serialized. Each host that executes a partition must set its own attempt timeout.

pub fn with_retry_policy(self, policy: impl Into<RetryPolicyArg>) -> Self

Sets the retry policy for this partition execution.

Note: This field is not serialized. Each host that executes a partition must set its own retry policy.

pub fn with_backoff_policy(self, policy: impl Into<BackoffPolicyArg>) -> Self

Sets the backoff policy for this partition execution.

Note: This field is not serialized. Each host that executes a partition must set its own backoff policy.

pub async fn execute(&self, client: &DatabaseClient) -> Result<ResultSet>

Executes this partition and returns a ResultSet that contains the rows that belong to this partition.

Example: executing a query partition

let db_client = spanner.database_client("projects/p/instances/i/databases/d").build().await?;
let transaction = db_client.batch_read_only_transaction().build().await?;
let partitions = transaction.partition_query(
    Statement::builder("SELECT * FROM Users").build(),
    PartitionOptions::default()
).await?;

// ... send partitions to other workers ...

// On a worker receiving a partition, execute it:
let mut result_set = partitions[0].execute(&db_client).await?;
while let Some(row) = result_set.next().await.transpose()? {
    // process row
}

Example: executing a read partition

let db_client = spanner.database_client("projects/p/instances/i/databases/d").build().await?;
let transaction = db_client.batch_read_only_transaction().build().await?;
let req = ReadRequest::builder("Users", vec!["Id", "Name"]).with_keys(KeySet::all()).build();
let partitions = transaction.partition_read(req, PartitionOptions::default()).await?;

// ... send partitions to other workers ...

// On a worker receiving a partition, execute it:
let mut result_set = partitions[0].execute(&db_client).await?;
while let Some(row) = result_set.next().await.transpose()? {
    // process row
}

A partition can be executed by any DatabaseClient that is connected to the database that the partitions belong to.

Trait Implementations

impl Clone for Partition

fn clone(&self) -> Partition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Partition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Partition

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Partition

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.