rdbc_rs/future/
rows.rs

1//! Asynchronous wrapper type for [`crate::driver::Rows`]
2
3use std::sync::{Arc, Mutex};
4
5use crate::driver;
6use anyhow::Result;
7
8use super::{driver::AsyncDriver, ConnectionPool, Statement};
9
10type Column = driver::Column;
11type ArgValue = driver::ArgValue;
12type ArgName = driver::ArgName;
13
14#[allow(dead_code)]
15struct Inner<DB>
16where
17    DB: ConnectionPool + Sync + Send,
18{
19    rows: Box<dyn driver::Rows>,
20    stmt: Statement<DB>,
21}
22
23/// Asynchronous wrapper type for [`crate::driver::Rows`]
24#[derive(Clone)]
25pub struct Rows<DB>
26where
27    DB: ConnectionPool + Sync + Send,
28{
29    inner: Arc<Mutex<Inner<DB>>>,
30}
31
32impl<DB> Rows<DB>
33where
34    DB: ConnectionPool + Sync + Send,
35{
36    pub(crate) fn new(rows: Box<dyn driver::Rows>, stmt: Statement<DB>) -> Self {
37        Self {
38            inner: Arc::new(Mutex::new(Inner { rows, stmt })),
39        }
40    }
41
42    pub async fn colunms(&mut self) -> Result<Vec<Column>> {
43        let async_driver = AsyncDriver::new();
44
45        {
46            let mut inner = self.inner.lock().unwrap();
47
48            inner.rows.colunms(async_driver.callback());
49        }
50
51        async_driver.await
52    }
53
54    pub async fn next(&mut self) -> Result<bool> {
55        let async_driver = AsyncDriver::new();
56
57        {
58            let mut inner = self.inner.lock().unwrap();
59
60            inner.rows.next(async_driver.callback());
61        }
62
63        async_driver.await
64    }
65
66    pub async fn get<N>(
67        &mut self,
68        name: N,
69        column_type: driver::ColumnType,
70    ) -> Result<Option<ArgValue>>
71    where
72        N: Into<ArgName>,
73    {
74        let async_driver = AsyncDriver::new();
75
76        {
77            let mut inner = self.inner.lock().unwrap();
78
79            inner
80                .rows
81                .get(name.into(), column_type, async_driver.callback());
82        }
83
84        async_driver.await
85    }
86}