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.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}