Skip to main content

uqa_engine/
async_sql_engine.rs

1//
2// Unified Query Algebra
3//
4// Copyright (c) 2023-2026 Cognica, Inc.
5//
6
7use std::future::{poll_fn, Future};
8use std::task::Poll;
9
10use uqa_sql::{AsyncSQLEngine, SQLError, SQLParam, SQLResult};
11
12use crate::Engine;
13
14impl AsyncSQLEngine for Engine {
15    type Error = SQLError;
16
17    fn sql<'a>(
18        &'a self,
19        query: &'a str,
20        params: &'a [SQLParam],
21    ) -> impl Future<Output = Result<SQLResult, Self::Error>> + Send + 'a {
22        poll_fn(move |_| Poll::Ready(Engine::sql(self, query, params)))
23    }
24
25    fn sql_batch<'a>(
26        &'a self,
27        statements: &'a [(&'a str, &'a [SQLParam])],
28    ) -> impl Future<Output = Result<Vec<SQLResult>, Self::Error>> + Send + 'a {
29        poll_fn(move |_| Poll::Ready(Engine::sql_batch(self, statements)))
30    }
31}
32
33#[cfg(test)]
34mod tests {
35    use super::*;
36    use std::task::{Context, Waker};
37
38    #[test]
39    fn a_sql_future_executes_only_when_polled() {
40        let engine = Engine::new();
41        let query = "CREATE TABLE async_single (id INTEGER)";
42        drop(AsyncSQLEngine::sql(&engine, query, &[]));
43        assert!(!engine.has_table("async_single").unwrap());
44        let mut future = std::pin::pin!(AsyncSQLEngine::sql(&engine, query, &[]));
45        assert!(!engine.has_table("async_single").unwrap());
46        let mut context = Context::from_waker(Waker::noop());
47        assert!(matches!(
48            future.as_mut().poll(&mut context),
49            Poll::Ready(Ok(_))
50        ));
51        assert!(engine.has_table("async_single").unwrap());
52    }
53
54    #[test]
55    fn a_batch_future_executes_only_when_polled() {
56        let engine = Engine::new();
57        let statements: &[(&str, &[SQLParam])] = &[
58            ("CREATE TABLE async_batch (id INTEGER)", &[]),
59            ("INSERT INTO async_batch VALUES (1)", &[]),
60        ];
61        drop(AsyncSQLEngine::sql_batch(&engine, statements));
62        assert!(!engine.has_table("async_batch").unwrap());
63        let mut future = std::pin::pin!(AsyncSQLEngine::sql_batch(&engine, statements));
64        assert!(!engine.has_table("async_batch").unwrap());
65        let mut context = Context::from_waker(Waker::noop());
66        let Poll::Ready(Ok(results)) = future.as_mut().poll(&mut context) else {
67            panic!("embedded SQL batch must complete on its first poll");
68        };
69        assert_eq!(results.len(), 2);
70        assert_eq!(
71            engine
72                .sql("SELECT id FROM async_batch", &[])
73                .unwrap()
74                .rows
75                .len(),
76            1
77        );
78    }
79}