Skip to main content

tank_core/
executor.rs

1use crate::{
2    AsEntity, AsQuery, Driver, DynQuery, Entity, Query, QueryResult, RawQuery, Result, Row,
3    RowsAffected, Sql,
4    stream::{Stream, StreamExt},
5    writer::SqlWriter,
6};
7use anyhow::anyhow;
8use convert_case::{Case, Casing};
9use std::{
10    future::{self, Future},
11    mem,
12    pin::{Pin, pin},
13    task::{self, Poll},
14};
15
16/// Stream adapter returned by [`Executor::fetch`], filtering [`Executor::run`] to rows.
17struct Fetched<S>(S);
18
19impl<S, R> Stream for Fetched<S>
20where
21    S: Stream<Item = Result<QueryResult<R>>>,
22{
23    type Item = Result<R>;
24
25    #[inline(always)]
26    fn poll_next(self: Pin<&mut Self>, cx: &mut task::Context<'_>) -> Poll<Option<Self::Item>> {
27        let mut inner = unsafe { self.map_unchecked_mut(|s| &mut s.0) };
28        loop {
29            match inner.as_mut().poll_next(cx) {
30                Poll::Ready(Some(Ok(QueryResult::Row(row)))) => return Poll::Ready(Some(Ok(row))),
31                Poll::Ready(Some(Ok(QueryResult::Affected(_)))) => {}
32                Poll::Ready(Some(Err(e))) => return Poll::Ready(Some(Err(e))),
33                Poll::Ready(None) => return Poll::Ready(None),
34                Poll::Pending => return Poll::Pending,
35            }
36        }
37    }
38
39    #[inline(always)]
40    fn size_hint(&self) -> (usize, Option<usize>) {
41        self.0.size_hint()
42    }
43}
44
45/// Async query execution.
46///
47/// Implemented by connections.
48pub trait Executor: Send {
49    /// Associated driver.
50    type Driver: Driver;
51
52    /// Checks if the driver supports multiple SQL statements in a single request.
53    fn accepts_multiple_statements(&self) -> bool {
54        true
55    }
56
57    /// Returns the driver instance associated with this executor.
58    fn driver(&self) -> Self::Driver {
59        Default::default()
60    }
61
62    /// Prepares a query for execution, returning a handle to the prepared statement.
63    fn prepare<'s>(
64        &'s mut self,
65        query: impl AsQuery<Self::Driver> + 's,
66    ) -> impl Future<Output = Result<Query<Self::Driver>>> + Send {
67        let mut query = query.as_query();
68        let query = mem::take(query.as_mut());
69        async {
70            match query {
71                Query::Raw(RawQuery(sql)) => self.do_prepare(sql).await,
72                Query::Prepared(..) => Ok(query),
73            }
74        }
75    }
76
77    /// Internal hook for implementing prepared statement support.
78    fn do_prepare(
79        &mut self,
80        _sql: String,
81    ) -> impl Future<Output = Result<Query<Self::Driver>>> + Send {
82        future::ready(Err(anyhow!(
83            "{} does not support prepare",
84            self.driver().name().to_case(Case::Pascal)
85        )))
86    }
87
88    /// Executes a query and streams the results (rows or affected counts).
89    fn run<'s>(
90        &'s mut self,
91        query: impl AsQuery<Self::Driver> + 's,
92    ) -> impl Stream<Item = Result<QueryResult<impl Row + 's>>> + Send;
93
94    /// Executes a query and streams the resulting rows, ignoring affected counts.
95    fn fetch<'s>(
96        &'s mut self,
97        query: impl AsQuery<Self::Driver> + 's,
98    ) -> impl Stream<Item = Result<impl Row + 's>> + Send {
99        Fetched(self.run(query))
100    }
101
102    /// Executes a query and returns the total number of affected rows.
103    fn execute<'s>(
104        &'s mut self,
105        query: impl AsQuery<Self::Driver> + 's,
106    ) -> impl Future<Output = Result<RowsAffected>> + Send {
107        let stream = self.run(query);
108        async move {
109            let mut stream = pin!(stream);
110            let mut affected = RowsAffected::default();
111            while let Some(item) = stream.next().await {
112                if let QueryResult::Affected(a) = item? {
113                    affected.extend([a]);
114                }
115            }
116            Ok(affected)
117        }
118    }
119
120    /// Efficiently inserts a collection of entities bypassing regular SQL execution when supported by the driver.
121    fn append<It>(&mut self, entities: It) -> impl Future<Output = Result<RowsAffected>> + Send
122    where
123        It: IntoIterator + Send,
124        It::IntoIter: Send,
125        It::Item: AsEntity,
126    {
127        let entities = entities.into_iter().collect::<Vec<_>>();
128        let mut query = DynQuery::default();
129        self.driver().sql_writer().write_insert(
130            &mut query,
131            Sql.insert_into(<It::Item as AsEntity>::Entity::table())
132                .values(entities.iter().map(AsEntity::as_entity)),
133        );
134        self.execute(query)
135    }
136}
137
138impl<S: Executor + ?Sized> Executor for &mut S {
139    type Driver = S::Driver;
140
141    fn accepts_multiple_statements(&self) -> bool {
142        (**self).accepts_multiple_statements()
143    }
144
145    fn driver(&self) -> Self::Driver {
146        (**self).driver()
147    }
148
149    fn prepare<'s>(
150        &'s mut self,
151        query: impl AsQuery<Self::Driver> + 's,
152    ) -> impl Future<Output = Result<Query<Self::Driver>>> + Send {
153        (**self).prepare(query)
154    }
155
156    fn do_prepare(
157        &mut self,
158        sql: String,
159    ) -> impl Future<Output = Result<Query<Self::Driver>>> + Send {
160        (**self).do_prepare(sql)
161    }
162
163    fn run<'s>(
164        &'s mut self,
165        query: impl AsQuery<Self::Driver> + 's,
166    ) -> impl Stream<Item = Result<QueryResult<impl Row + 's>>> + Send {
167        (**self).run(query)
168    }
169
170    fn fetch<'s>(
171        &'s mut self,
172        query: impl AsQuery<Self::Driver> + 's,
173    ) -> impl Stream<Item = Result<impl Row + 's>> + Send {
174        (**self).fetch(query)
175    }
176
177    fn execute<'s>(
178        &'s mut self,
179        query: impl AsQuery<Self::Driver> + 's,
180    ) -> impl Future<Output = Result<RowsAffected>> + Send {
181        (**self).execute(query)
182    }
183
184    fn append<It>(&mut self, entities: It) -> impl Future<Output = Result<RowsAffected>> + Send
185    where
186        It: IntoIterator + Send,
187        It::IntoIter: Send,
188        It::Item: AsEntity,
189    {
190        (**self).append(entities)
191    }
192}