Skip to content

Commit 5ed78cd

Browse files
authored
perf(bigquery): remove tokio::spawn from AppendWithOffset (#6937)
In `AppendWithOffset::send()`, eliminate the intermediate oneshot channel and background `tokio::spawn` task by returning an inline async future via `AppendFuture::from_future`. Fixes #6898
1 parent e9b264e commit 5ed78cd

2 files changed

Lines changed: 107 additions & 24 deletions

File tree

‎src/bigquery/src/write/append_future.rs‎

Lines changed: 65 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -29,23 +29,53 @@ use tokio::sync::oneshot;
2929
/// background, even if this future is dropped or never awaited.
3030
#[derive(Debug)]
3131
pub struct AppendFuture {
32-
rx: oneshot::Receiver<AppendResult<AppendResponse>>,
32+
inner: Inner,
33+
}
34+
35+
enum Inner {
36+
Rx(oneshot::Receiver<AppendResult<AppendResponse>>),
37+
Boxed(Pin<Box<dyn Future<Output = AppendResult<AppendResponse>> + Send>>),
38+
}
39+
40+
impl std::fmt::Debug for Inner {
41+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
42+
match self {
43+
Self::Rx(rx) => f.debug_tuple("Rx").field(rx).finish(),
44+
Self::Boxed(_) => f.debug_tuple("Boxed").finish(),
45+
}
46+
}
3347
}
3448

3549
impl AppendFuture {
3650
pub(crate) fn new(rx: oneshot::Receiver<AppendResult<AppendResponse>>) -> Self {
37-
Self { rx }
51+
Self {
52+
inner: Inner::Rx(rx),
53+
}
54+
}
55+
56+
pub(crate) fn from_future<F>(fut: F) -> Self
57+
where
58+
F: Future<Output = AppendResult<AppendResponse>> + Send + 'static,
59+
{
60+
Self {
61+
inner: Inner::Boxed(Box::pin(fut)),
62+
}
3863
}
3964
}
4065

4166
impl Future for AppendFuture {
4267
type Output = AppendResult<AppendResponse>;
4368

4469
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
45-
let result = std::task::ready!(Pin::new(&mut self.rx).poll(cx));
46-
match result {
47-
Ok(res) => Poll::Ready(res),
48-
Err(_) => Poll::Ready(Err(AppendError::UnexpectedEndOfStream)),
70+
match &mut self.inner {
71+
Inner::Rx(rx) => {
72+
let result = std::task::ready!(Pin::new(rx).poll(cx));
73+
match result {
74+
Ok(res) => Poll::Ready(res),
75+
Err(_) => Poll::Ready(Err(AppendError::UnexpectedEndOfStream)),
76+
}
77+
}
78+
Inner::Boxed(fut) => fut.as_mut().poll(cx),
4979
}
5080
}
5181
}
@@ -89,4 +119,33 @@ mod tests {
89119
let err = future.await.expect_err("should return error from task");
90120
assert!(matches!(err, AppendError::UnexpectedEndOfStream));
91121
}
122+
123+
#[tokio::test]
124+
async fn from_future_success() {
125+
let future = AppendFuture::from_future(async {
126+
Ok(AppendResponse {
127+
offset: Some(7),
128+
updated_schema: None,
129+
})
130+
});
131+
let resp = future.await.expect("should succeed");
132+
assert_eq!(resp.offset, Some(7));
133+
}
134+
135+
#[tokio::test]
136+
async fn from_future_error() {
137+
let future = AppendFuture::from_future(async { Err(AppendError::UnexpectedEndOfStream) });
138+
let err = future.await.expect_err("should return error");
139+
assert!(matches!(err, AppendError::UnexpectedEndOfStream));
140+
}
141+
142+
#[test]
143+
fn debug_format() {
144+
let (_, rx) = oneshot::channel();
145+
let future_rx = AppendFuture::new(rx);
146+
assert!(format!("{future_rx:?}").contains("Rx"));
147+
148+
let future_boxed = AppendFuture::from_future(async { Ok(AppendResponse::default()) });
149+
assert!(format!("{future_boxed:?}").contains("Boxed"));
150+
}
92151
}

‎src/bigquery/src/write/builder/append_with_offset.rs‎

Lines changed: 42 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -84,29 +84,24 @@ impl AppendWithOffset {
8484
/// }
8585
/// ```
8686
pub fn send(self) -> AppendFuture {
87-
let (tx, rx) = oneshot::channel();
8887
let (resp_tx, resp_rx) = oneshot::channel();
8988
let req = match self.req.to_proto().map_err(Error::ser) {
9089
Ok(req) => req,
91-
Err(e) => {
92-
let _ = tx.send(Err(e.into()));
93-
return AppendFuture::new(rx);
94-
}
90+
Err(e) => return AppendFuture::from_future(async move { Err(e.into()) }),
9591
};
9692
let write = WriteRequest { req, resp_tx };
97-
let _ = self.req_tx.send(write);
98-
tokio::spawn(async move {
99-
let res = async {
100-
let resp = resp_rx
101-
.await
102-
.map_err(|_| AppendError::UnexpectedEndOfStream)??;
103-
let resp = resp.cnv().map_err(Error::deser)?;
104-
to_result(resp)
105-
}
106-
.await;
107-
let _ = tx.send(res);
108-
});
109-
AppendFuture::new(rx)
93+
if self.req_tx.send(write).is_err() {
94+
return AppendFuture::from_future(
95+
async move { Err(AppendError::UnexpectedEndOfStream) },
96+
);
97+
}
98+
AppendFuture::from_future(async move {
99+
let resp = resp_rx
100+
.await
101+
.map_err(|_| AppendError::UnexpectedEndOfStream)??;
102+
let resp = resp.cnv().map_err(Error::deser)?;
103+
to_result(resp)
104+
})
110105
}
111106
}
112107

@@ -236,4 +231,33 @@ mod tests {
236231
write_handle.await?;
237232
Ok(())
238233
}
234+
235+
#[tokio::test]
236+
async fn send_when_req_tx_closed_returns_unexpected_end_of_stream() {
237+
let (req_tx, req_rx) = mpsc::unbounded_channel();
238+
drop(req_rx);
239+
240+
let req = AppendRowsRequest::new().set_write_stream(write_stream());
241+
let builder = AppendWithOffset::new(req_tx, req).set_offset(100);
242+
let future = builder.send();
243+
244+
let err = future
245+
.await
246+
.expect_err("should return unexpected end of stream");
247+
assert!(matches!(err, AppendError::UnexpectedEndOfStream));
248+
}
249+
250+
#[tokio::test]
251+
async fn send_serialization_error() {
252+
use crate::model::append_rows_request::MissingValueInterpretation;
253+
254+
let (req_tx, _req_rx) = mpsc::unbounded_channel();
255+
let invalid: MissingValueInterpretation = serde_json::from_str("\"INVALID\"").unwrap();
256+
let req = AppendRowsRequest::new().set_default_missing_value_interpretation(invalid);
257+
let builder = AppendWithOffset::new(req_tx, req).set_offset(100);
258+
let future = builder.send();
259+
260+
let err = future.await.expect_err("should return serialization error");
261+
assert!(matches!(err, AppendError::Rpc { .. }));
262+
}
239263
}

0 commit comments

Comments
 (0)