use crate::fluent_api::row_changes::BigQueryRowChanges;
use crate::{
BigQueryChange, BigQueryChangeType, BigQueryInsertParams, BigQueryResult,
BigQueryStreamingWriteOptions, BigQueryTableRef, BigQueryWriteMode, BigQueryWriteSummary,
BigQueryWriteSupport,
};
use arrow_array::RecordBatch;
use serde::Serialize;
#[derive(Clone, Debug)]
pub struct BigQueryInsertInitialBuilder<'a, D>
where
D: BigQueryWriteSupport,
{
db: &'a D,
}
impl<'a, D> BigQueryInsertInitialBuilder<'a, D>
where
D: BigQueryWriteSupport,
{
pub(crate) fn new(db: &'a D) -> Self {
Self { db }
}
#[inline]
pub fn into(self, table: impl Into<BigQueryTableRef>) -> BigQueryInsertTableBuilder<'a, D> {
BigQueryInsertTableBuilder {
db: self.db,
params: BigQueryInsertParams::new(table.into()),
}
}
}
#[derive(Clone, Debug)]
pub struct BigQueryInsertTableBuilder<'a, D>
where
D: BigQueryWriteSupport,
{
db: &'a D,
params: BigQueryInsertParams,
}
impl<'a, D> BigQueryInsertTableBuilder<'a, D>
where
D: BigQueryWriteSupport,
{
#[inline]
pub fn object<'o, T: Serialize + Sync>(
self,
row: &'o T,
) -> BigQueryInsertObjBuilder<'a, D, std::iter::Once<&'o T>> {
self.objects(std::iter::once(row))
}
#[inline]
pub fn objects<I>(self, rows: I) -> BigQueryInsertObjBuilder<'a, D, I>
where
I: IntoIterator + Send,
I::Item: Serialize + Send + Sync,
I::IntoIter: Send,
{
BigQueryInsertObjBuilder {
db: self.db,
params: self.params,
rows,
upsert: false,
}
}
#[inline]
pub fn record_batches<I>(self, batches: I) -> BigQueryInsertRecordBatchesBuilder<'a, D, I>
where
I: IntoIterator<Item = RecordBatch> + Send,
I::IntoIter: Send,
{
BigQueryInsertRecordBatchesBuilder {
db: self.db,
params: self.params,
batches,
}
}
#[inline]
pub fn changes<T, I>(self, changes: I) -> BigQueryInsertChangesBuilder<'a, D, I>
where
T: Serialize + Send + Sync,
I: IntoIterator<Item = BigQueryChange<T>> + Send,
I::IntoIter: Send,
{
BigQueryInsertChangesBuilder {
db: self.db,
params: self.params,
changes,
}
}
}
#[derive(Clone, Debug)]
pub struct BigQueryInsertObjBuilder<'a, D, I>
where
D: BigQueryWriteSupport,
{
db: &'a D,
params: BigQueryInsertParams,
rows: I,
upsert: bool,
}
impl<'a, D, I> BigQueryInsertObjBuilder<'a, D, I>
where
D: BigQueryWriteSupport,
I: IntoIterator + Send,
I::Item: Serialize + Send + Sync,
I::IntoIter: Send,
{
#[inline]
pub fn exactly_once(mut self) -> Self {
self.params.options.mode = BigQueryWriteMode::Committed;
self
}
#[inline]
pub fn atomic(mut self) -> Self {
self.params.options.mode = BigQueryWriteMode::Pending;
self
}
#[inline]
pub fn buffered(mut self) -> Self {
self.params.options.mode = BigQueryWriteMode::Buffered;
self
}
#[inline]
pub fn upsert(mut self) -> Self {
self.upsert = true;
self
}
#[inline]
pub fn options(mut self, options: BigQueryStreamingWriteOptions) -> Self {
self.params.options = options;
self
}
pub async fn execute(self) -> BigQueryResult<BigQueryWriteSummary> {
if !self.upsert {
return self.db.insert_objects(self.params, self.rows).await;
}
BigQueryRowChanges::new(self.params, BigQueryChangeType::Upsert, self.rows)
.execute(self.db)
.await
}
}
#[derive(Clone, Debug)]
pub struct BigQueryInsertChangesBuilder<'a, D, I>
where
D: BigQueryWriteSupport,
{
db: &'a D,
params: BigQueryInsertParams,
changes: I,
}
impl<'a, D, T, I> BigQueryInsertChangesBuilder<'a, D, I>
where
D: BigQueryWriteSupport,
T: Serialize + Send + Sync,
I: IntoIterator<Item = BigQueryChange<T>> + Send,
I::IntoIter: Send,
{
#[inline]
pub fn options(mut self, options: BigQueryStreamingWriteOptions) -> Self {
self.params.options = options;
self
}
pub async fn execute(self) -> BigQueryResult<BigQueryWriteSummary> {
self.db.insert_changes(self.params, self.changes).await
}
}
#[derive(Clone, Debug)]
pub struct BigQueryInsertRecordBatchesBuilder<'a, D, I>
where
D: BigQueryWriteSupport,
{
db: &'a D,
params: BigQueryInsertParams,
batches: I,
}
impl<'a, D, I> BigQueryInsertRecordBatchesBuilder<'a, D, I>
where
D: BigQueryWriteSupport,
I: IntoIterator<Item = RecordBatch> + Send,
I::IntoIter: Send,
{
#[inline]
pub fn exactly_once(mut self) -> Self {
self.params.options.mode = BigQueryWriteMode::Committed;
self
}
#[inline]
pub fn atomic(mut self) -> Self {
self.params.options.mode = BigQueryWriteMode::Pending;
self
}
#[inline]
pub fn buffered(mut self) -> Self {
self.params.options.mode = BigQueryWriteMode::Buffered;
self
}
#[inline]
pub fn options(mut self, options: BigQueryStreamingWriteOptions) -> Self {
self.params.options = options;
self
}
pub async fn execute(self) -> BigQueryResult<BigQueryWriteSummary> {
self.db
.insert_record_batches(self.params, self.batches)
.await
}
}