use super::*;
pub async fn consume_stream<S, F>(
stream: S,
mut on_batch: F,
) -> std::result::Result<StreamSummary, tonic::Status>
where
S: Stream<Item = std::result::Result<QueryResultBatch, tonic::Status>> + Unpin,
F: FnMut(&QueryResultBatch) -> ControlFlow<()>,
{
let mut stream = stream;
let mut summary = StreamSummary::default();
while let Some(item) = stream.next().await {
let batch = item?;
summary.batches += 1;
summary.rows += batch.records.len();
summary.running_total_emitted = batch.running_total_emitted;
summary.is_last_batch = batch.is_last_batch;
if on_batch(&batch).is_break() {
summary.truncated = true;
return Ok(summary);
}
}
Ok(summary)
}
impl ArcadeDbClient {
pub async fn stream_query<F>(
&self,
database: &str,
query: &str,
on_batch: F,
) -> Result<StreamSummary>
where
F: FnMut(&QueryResultBatch) -> ControlFlow<()>,
{
self.stream_query_impl(
database,
query,
crate::encode::Params::default(),
crate::stream::StreamOptions::default(),
on_batch,
)
.await
}
pub async fn stream_query_with_values<F>(
&self,
database: &str,
query: &str,
parameters: impl Into<crate::encode::Params>,
on_batch: F,
) -> Result<StreamSummary>
where
F: FnMut(&QueryResultBatch) -> ControlFlow<()>,
{
let parameters = parameters.into();
self.stream_query_impl(
database,
query,
parameters,
crate::stream::StreamOptions::default(),
on_batch,
)
.await
}
pub async fn stream_query_with_options<F>(
&self,
database: &str,
query: &str,
parameters: impl Into<crate::encode::Params>,
options: crate::stream::StreamOptions,
on_batch: F,
) -> Result<StreamSummary>
where
F: FnMut(&QueryResultBatch) -> ControlFlow<()>,
{
self.stream_query_impl(database, query, parameters.into(), options, on_batch)
.await
}
pub async fn stream_query_rows<T, F>(
&self,
database: &str,
query: &str,
parameters: impl Into<crate::encode::Params>,
on_row: F,
) -> Result<StreamSummary>
where
T: for<'r> TryFrom<&'r GrpcRecord, Error = RecordDecodeError>,
F: FnMut(T) -> ControlFlow<()>,
{
self.stream_query_rows_impl(
database,
query,
parameters,
crate::stream::StreamOptions::default(),
on_row,
)
.await
}
pub async fn stream_query_rows_with_options<T, F>(
&self,
database: &str,
query: &str,
parameters: impl Into<crate::encode::Params>,
options: crate::stream::StreamOptions,
on_row: F,
) -> Result<StreamSummary>
where
T: for<'r> TryFrom<&'r GrpcRecord, Error = RecordDecodeError>,
F: FnMut(T) -> ControlFlow<()>,
{
self.stream_query_rows_impl(database, query, parameters, options, on_row)
.await
}
pub(crate) async fn stream_query_impl<F>(
&self,
database: &str,
query: &str,
parameters: crate::encode::Params,
options: crate::stream::StreamOptions,
on_batch: F,
) -> Result<StreamSummary>
where
F: FnMut(&QueryResultBatch) -> ControlFlow<()>,
{
let req = tonic::Request::new(StreamQueryRequest {
database: database.into(),
query: query.into(),
parameters: parameters.0,
credentials: Some(self.auth.creds.clone()),
language: "sql".into(),
batch_size: options.batch_size,
retrieval_mode: options.retrieval_mode.map_or(0, |m| m as i32),
projection_settings: options.projection,
..Default::default()
});
let streaming = self
.data
.clone()
.stream_query(self.add_auth_headers(req))
.await
.map_err(|e| map_rpc_error("stream_query", query, e))?
.into_inner();
let summary = consume_stream(streaming, on_batch)
.await
.map_err(|e| map_rpc_error("stream_query", query, e))?;
tracing::info!(
count = summary.rows,
batches = summary.batches,
truncated = summary.truncated,
query = %query,
"stream query results"
);
Ok(summary)
}
pub(crate) async fn stream_query_rows_impl<T, F>(
&self,
database: &str,
query: &str,
parameters: impl Into<crate::encode::Params>,
options: crate::stream::StreamOptions,
mut on_row: F,
) -> Result<StreamSummary>
where
T: for<'r> TryFrom<&'r GrpcRecord, Error = RecordDecodeError>,
F: FnMut(T) -> ControlFlow<()>,
{
let mut row_error: Option<ArcadeDbError> = None;
let mut stopped = false;
let result = self
.stream_query_impl(database, query, parameters.into(), options, |batch| {
if stopped {
return ControlFlow::Break(());
}
for record in &batch.records {
match T::try_from(record) {
Ok(row) => {
if let ControlFlow::Break(()) = on_row(row) {
stopped = true;
return ControlFlow::Break(());
}
}
Err(e) => {
row_error = Some(ArcadeDbError::Decode {
what: format!("stream row of `{query}`"),
source: e,
});
stopped = true;
return ControlFlow::Break(());
}
}
}
ControlFlow::Continue(())
})
.await;
if let Some(e) = row_error {
return Err(e);
}
result
}
}