bigquery 0.10.0

Library provides a simple API for Google BigQuery based on the gRPC Storage Read/Write and v2 APIs
Documentation
//! [`BigQueryWriteSupport`] for [`BigQueryDb`]: one writer per insert.

use crate::write::connection::{FinishKind, Finished};
use crate::write::writer::WriterCore;
use crate::{
    BigQueryChange, BigQueryDb, BigQueryInsertParams, BigQueryResult, BigQueryWriteSummary,
    BigQueryWriteSupport,
};
use arrow_array::RecordBatch;
use async_trait::async_trait;
use serde::Serialize;

impl Finished {
    /// The summary of a finished insert, or the first failed batch's error.
    fn into_result(self) -> BigQueryResult<BigQueryWriteSummary> {
        match self.first_error {
            Some(err) => Err(err),
            None => Ok(self.summary),
        }
    }
}

#[async_trait]
impl BigQueryWriteSupport for BigQueryDb {
    async fn insert_objects<T, I>(
        &self,
        params: BigQueryInsertParams,
        rows: I,
    ) -> BigQueryResult<BigQueryWriteSummary>
    where
        T: Serialize + Send + Sync,
        I: IntoIterator<Item = T> + Send,
        I::IntoIter: Send,
    {
        let (mut core, _responses) =
            WriterCore::open(self, params.table, params.options, false).await?;
        for row in rows {
            if let Err(err) = core
                .write_with(|encoder, out| encoder.encode(&row, out))
                .await
            {
                core.abandon();
                return Err(err);
            }
        }
        (core.finish(FinishKind::Close).await?).into_result()
    }

    async fn insert_record_batches<I>(
        &self,
        params: BigQueryInsertParams,
        batches: I,
    ) -> BigQueryResult<BigQueryWriteSummary>
    where
        I: IntoIterator<Item = RecordBatch> + Send,
        I::IntoIter: Send,
    {
        let (mut core, _responses) =
            WriterCore::open(self, params.table, params.options, false).await?;
        for batch in batches {
            if let Err(err) = core.write_record_batch(&batch).await {
                core.abandon();
                return Err(err);
            }
        }
        (core.finish(FinishKind::Close).await?).into_result()
    }

    async fn insert_changes<T, I>(
        &self,
        params: BigQueryInsertParams,
        changes: I,
    ) -> BigQueryResult<BigQueryWriteSummary>
    where
        T: Serialize + Send + Sync,
        I: IntoIterator<Item = BigQueryChange<T>> + Send,
        I::IntoIter: Send,
    {
        let (mut core, _responses) =
            WriterCore::open(self, params.table, params.options, true).await?;
        for change in changes {
            let written = core
                .write_with(|encoder, out| {
                    encoder.encode_change(
                        &change.row,
                        change.change_type,
                        change.sequence_number.as_ref(),
                        out,
                    )
                })
                .await;
            if let Err(err) = written {
                core.abandon();
                return Err(err);
            }
        }
        (core.finish(FinishKind::Close).await?).into_result()
    }
}