use crate::errors::BigQueryError;
use crate::BigQueryInstant;
use crate::{
BigQueryFilter, BigQueryFilterBuilder, BigQueryReadOptions, BigQueryReadParams,
BigQueryReadSupport, BigQueryResult, BigQueryTableRef,
};
use arrow_array::RecordBatch;
use futures::stream::BoxStream;
use serde::de::DeserializeOwned;
use std::marker::PhantomData;
#[derive(Clone, Debug)]
pub struct BigQuerySelectInitialBuilder<'a, D>
where
D: BigQueryReadSupport,
{
db: &'a D,
selected_fields: Option<Vec<String>>,
}
impl<'a, D> BigQuerySelectInitialBuilder<'a, D>
where
D: BigQueryReadSupport,
{
pub(crate) fn new(db: &'a D) -> Self {
Self {
db,
selected_fields: None,
}
}
pub fn fields<I>(self, fields: I) -> Self
where
I: IntoIterator,
I::Item: AsRef<str>,
{
Self {
selected_fields: Some(fields.into_iter().map(|f| f.as_ref().to_string()).collect()),
..self
}
}
pub fn from(self, table: impl Into<BigQueryTableRef>) -> BigQuerySelectBuilder<'a, D> {
let params =
BigQueryReadParams::new(table.into()).opt_selected_fields(self.selected_fields);
BigQuerySelectBuilder {
db: self.db,
params,
filter_failure: None,
}
}
}
#[derive(Clone, Debug)]
pub struct BigQuerySelectBuilder<'a, D>
where
D: BigQueryReadSupport,
{
db: &'a D,
params: BigQueryReadParams,
filter_failure: Option<BigQueryError>,
}
impl<'a, D> BigQuerySelectBuilder<'a, D>
where
D: BigQueryReadSupport,
{
pub fn filter<FN>(self, filter: FN) -> Self
where
FN: FnOnce(BigQueryFilterBuilder) -> Option<BigQueryFilter>,
{
let (row_restriction, filter_failure) =
match filter(BigQueryFilterBuilder::new()).map(BigQueryFilter::into_row_restriction) {
None => (None, None),
Some(Ok(sql)) => (Some(sql), None),
Some(Err(failure)) => (None, Some(failure)),
};
Self {
params: BigQueryReadParams {
row_restriction,
..self.params
},
filter_failure,
..self
}
}
pub fn filter_sql(self, row_restriction: impl Into<String>) -> Self {
Self {
params: self.params.with_row_restriction(row_restriction.into()),
filter_failure: None,
..self
}
}
pub fn snapshot_time(self, snapshot_time: BigQueryInstant) -> Self {
Self {
params: self.params.with_snapshot_time(snapshot_time),
..self
}
}
pub fn sample_percentage(self, percentage: f64) -> Self {
Self {
params: self.params.with_sample_percentage(percentage),
..self
}
}
pub fn options(self, options: BigQueryReadOptions) -> Self {
Self {
params: self.params.with_options(options),
..self
}
}
pub fn obj<T>(self) -> BigQuerySelectObjBuilder<'a, D, T>
where
T: DeserializeOwned + Send + 'static,
{
BigQuerySelectObjBuilder {
db: self.db,
params: self.params,
filter_failure: self.filter_failure,
_target: PhantomData,
}
}
pub async fn record_batches<'b>(
self,
) -> BigQueryResult<BoxStream<'b, BigQueryResult<RecordBatch>>> {
if let Some(failure) = self.filter_failure {
return Err(failure);
}
self.db.stream_read_record_batches(self.params).await
}
}
#[derive(Clone, Debug)]
pub struct BigQuerySelectObjBuilder<'a, D, T>
where
D: BigQueryReadSupport,
{
db: &'a D,
params: BigQueryReadParams,
filter_failure: Option<BigQueryError>,
_target: PhantomData<fn() -> T>,
}
impl<'a, D, T> BigQuerySelectObjBuilder<'a, D, T>
where
D: BigQueryReadSupport,
T: DeserializeOwned + Send + 'static,
{
fn checked_params(self) -> BigQueryResult<BigQueryReadParams> {
match self.filter_failure {
Some(failure) => Err(failure),
None => Ok(self.params),
}
}
pub async fn query(self) -> BigQueryResult<Vec<T>> {
let db = self.db;
db.read_obj(self.checked_params()?).await
}
pub async fn stream_query<'b>(self) -> BigQueryResult<BoxStream<'b, T>> {
let db = self.db;
db.stream_read_obj(self.checked_params()?).await
}
pub async fn stream_query_with_errors<'b>(
self,
) -> BigQueryResult<BoxStream<'b, BigQueryResult<T>>> {
let db = self.db;
db.stream_read_obj_with_errors(self.checked_params()?).await
}
}