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
16struct 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
45pub trait Executor: Send {
49 type Driver: Driver;
51
52 fn accepts_multiple_statements(&self) -> bool {
54 true
55 }
56
57 fn driver(&self) -> Self::Driver {
59 Default::default()
60 }
61
62 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 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 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 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 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 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}