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()
132                .insert_into(<It::Item as AsEntity>::Entity::table())
133                .values(entities.iter().map(AsEntity::as_entity)),
134        );
135        self.execute(query)
136    }
137}
138
139impl<S: Executor + ?Sized> Executor for &mut S {
140    type Driver = S::Driver;
141
142    fn accepts_multiple_statements(&self) -> bool {
143        (**self).accepts_multiple_statements()
144    }
145
146    fn driver(&self) -> Self::Driver {
147        (**self).driver()
148    }
149
150    fn prepare<'s>(
151        &'s mut self,
152        query: impl AsQuery<Self::Driver> + 's,
153    ) -> impl Future<Output = Result<Query<Self::Driver>>> + Send {
154        (**self).prepare(query)
155    }
156
157    fn do_prepare(
158        &mut self,
159        sql: String,
160    ) -> impl Future<Output = Result<Query<Self::Driver>>> + Send {
161        (**self).do_prepare(sql)
162    }
163
164    fn run<'s>(
165        &'s mut self,
166        query: impl AsQuery<Self::Driver> + 's,
167    ) -> impl Stream<Item = Result<QueryResult<impl Row + 's>>> + Send {
168        (**self).run(query)
169    }
170
171    fn fetch<'s>(
172        &'s mut self,
173        query: impl AsQuery<Self::Driver> + 's,
174    ) -> impl Stream<Item = Result<impl Row + 's>> + Send {
175        (**self).fetch(query)
176    }
177
178    fn execute<'s>(
179        &'s mut self,
180        query: impl AsQuery<Self::Driver> + 's,
181    ) -> impl Future<Output = Result<RowsAffected>> + Send {
182        (**self).execute(query)
183    }
184
185    fn append<It>(&mut self, entities: It) -> impl Future<Output = Result<RowsAffected>> + Send
186    where
187        It: IntoIterator + Send,
188        It::IntoIter: Send,
189        It::Item: AsEntity,
190    {
191        (**self).append(entities)
192    }
193}