1use crate::error::Error;
2use crate::executor::{Execute, Executor};
3use crate::io::{PortalId, StatementId};
4use crate::logger::QueryLogger;
5use crate::message::{
6 self, BackendMessageFormat, Bind, Close, CommandComplete, DataRow, ParameterDescription, Parse,
7 ParseComplete, RowDescription,
8};
9use crate::statement::PgStatementMetadata;
10use crate::{
11 statement::PgStatement, PgArguments, PgConnection, PgDatabaseError, PgQueryResult, PgRow,
12 PgTypeInfo, PgValueFormat, Postgres,
13};
14use futures_core::future::BoxFuture;
15use futures_core::stream::BoxStream;
16use futures_core::Stream;
17use futures_util::TryStreamExt;
18use sqlx_core::arguments::Arguments;
19use sqlx_core::sql_str::SqlStr;
20use sqlx_core::Either;
21use std::{pin::pin, sync::Arc};
22
23async fn prepare(
24 conn: &mut PgConnection,
25 sql: &str,
26 arg_types: &[PgTypeInfo],
27 metadata: Option<Arc<PgStatementMetadata>>,
28 persistent: bool,
29 resolve_column_origin: bool,
30) -> Result<(StatementId, Arc<PgStatementMetadata>), Error> {
31 let id = if persistent && conn.inner.cache_statement.is_enabled() {
34 let id = conn.inner.next_statement_id;
35 conn.inner.next_statement_id = id.next();
36 id
37 } else {
38 StatementId::UNNAMED
39 };
40
41 let param_types = conn.resolve_types(arg_types).await?;
45
46 conn.wait_until_ready().await?;
48
49 conn.inner.stream.write_msg(Parse {
51 param_types: ¶m_types,
52 query: sql,
53 statement: id,
54 })?;
55
56 if metadata.is_none() {
57 conn.inner
59 .stream
60 .write_msg(message::Describe::Statement(id))?;
61 }
62
63 conn.write_sync();
65 conn.inner.stream.flush().await?;
66
67 conn.inner.stream.recv_expect::<ParseComplete>().await?;
69
70 let (metadata, ran_catalog_query) = if let Some(metadata) = metadata {
71 conn.recv_ready_for_query().await?;
73
74 (metadata, false)
76 } else {
77 let parameters = recv_desc_params(conn).await?;
78
79 let row_desc = recv_desc_rows(conn).await?;
80
81 conn.recv_ready_for_query().await?;
83
84 let (metadata, ran_catalog_query) = conn
85 .resolve_statement_metadata::<true>(Some(parameters), row_desc, resolve_column_origin)
86 .await?;
87
88 conn.wait_until_ready().await?;
91
92 (metadata, ran_catalog_query)
93 };
94
95 if !persistent && ran_catalog_query {
99 conn.inner.stream.write_msg(Parse {
100 param_types: ¶m_types,
101 query: sql,
102 statement: id,
103 })?;
104 conn.write_sync();
105 conn.inner.stream.flush().await?;
106 conn.inner.stream.recv_expect::<ParseComplete>().await?;
107 conn.recv_ready_for_query().await?;
108 }
109
110 Ok((id, metadata))
111}
112
113async fn recv_desc_params(conn: &mut PgConnection) -> Result<ParameterDescription, Error> {
114 conn.inner.stream.recv_expect().await
115}
116
117async fn recv_desc_rows(conn: &mut PgConnection) -> Result<Option<RowDescription>, Error> {
118 let rows: Option<RowDescription> = match conn.inner.stream.recv().await? {
119 message if message.format == BackendMessageFormat::RowDescription => {
121 Some(message.decode()?)
122 }
123
124 message if message.format == BackendMessageFormat::NoData => None,
126
127 message => {
128 return Err(err_protocol!(
129 "expecting RowDescription or NoData but received {:?}",
130 message.format
131 ));
132 }
133 };
134
135 Ok(rows)
136}
137
138impl PgConnection {
139 pub(super) async fn wait_for_close_complete(&mut self, mut count: usize) -> Result<(), Error> {
141 while count > 0 {
143 match self.inner.stream.recv().await? {
144 message if message.format == BackendMessageFormat::PortalSuspended => {
145 }
148
149 message if message.format == BackendMessageFormat::CloseComplete => {
150 count -= 1;
152 }
153
154 message => {
155 return Err(err_protocol!(
156 "expecting PortalSuspended or CloseComplete but received {:?}",
157 message.format
158 ));
159 }
160 }
161 }
162
163 Ok(())
164 }
165
166 #[inline(always)]
167 pub(crate) fn write_sync(&mut self) {
168 self.inner
169 .stream
170 .write_msg(message::Sync)
171 .expect("BUG: Sync should not be too big for protocol");
172
173 self.inner.pending_ready_for_query_count += 1;
175 }
176
177 async fn get_or_prepare(
178 &mut self,
179 sql: &str,
180 parameters: &[PgTypeInfo],
181 persistent: bool,
182 metadata: Option<Arc<PgStatementMetadata>>,
185 resolve_column_origin: bool,
186 ) -> Result<(StatementId, Arc<PgStatementMetadata>), Error> {
187 if let Some(statement) = self.inner.cache_statement.get_mut(sql) {
188 return Ok((*statement).clone());
189 }
190
191 let statement = prepare(
192 self,
193 sql,
194 parameters,
195 metadata,
196 persistent,
197 resolve_column_origin,
198 )
199 .await?;
200
201 if persistent && self.inner.cache_statement.is_enabled() {
202 if let Some((id, _)) = self.inner.cache_statement.insert(sql, statement.clone()) {
203 self.inner.stream.write_msg(Close::Statement(id))?;
204 self.write_sync();
205
206 self.inner.stream.flush().await?;
207
208 self.wait_for_close_complete(1).await?;
209 self.recv_ready_for_query().await?;
210 }
211 }
212
213 Ok(statement)
214 }
215
216 async fn try_get_or_prepare<'e, 'c: 'e, 'q: 'e>(
217 &'c mut self,
218 sql: &str,
219 arguments: Option<&mut PgArguments>,
220 persistent: bool,
221 metadata_opt: Option<Arc<PgStatementMetadata>>,
222 ) -> Result<(PgValueFormat, Arc<PgStatementMetadata>), Error> {
223 let metadata: Arc<PgStatementMetadata>;
224
225 let format = if let Some(arguments) = arguments {
226 let num_params = u16::try_from(arguments.len()).map_err(|_| {
233 err_protocol!(
234 "PgConnection::run(): too many arguments for query: {}",
235 arguments.len()
236 )
237 })?;
238
239 let (statement, metadata_) = self
242 .get_or_prepare(sql, &arguments.types, persistent, metadata_opt, false)
243 .await?;
244
245 metadata = metadata_;
246
247 arguments.apply_patches(self, &metadata.parameters).await?;
249
250 self.wait_until_ready().await?;
252
253 self.inner.stream.write_msg(Bind {
255 portal: PortalId::UNNAMED,
256 statement,
257 formats: &[PgValueFormat::Binary],
258 num_params,
259 params: &arguments.buffer,
260 result_formats: &[PgValueFormat::Binary],
261 })?;
262
263 self.inner.stream.write_msg(message::Execute {
266 portal: PortalId::UNNAMED,
267 limit: 0,
270 })?;
271 self.inner
281 .stream
282 .write_msg(Close::Portal(PortalId::UNNAMED))?;
283
284 self.write_sync();
290
291 PgValueFormat::Binary
293 } else {
294 self.queue_simple_query(sql)?;
296
297 metadata = Arc::new(PgStatementMetadata::default());
299
300 PgValueFormat::Text
302 };
303
304 self.inner.stream.flush().await?;
305
306 Ok((format, metadata))
307 }
308
309 pub(crate) async fn run<'e, 'c: 'e, 'q: 'e>(
310 &'c mut self,
311 query: SqlStr,
312 mut arguments: Option<PgArguments>,
313 persistent: bool,
314 metadata_opt: Option<Arc<PgStatementMetadata>>,
315 ) -> Result<impl Stream<Item = Result<Either<PgQueryResult, PgRow>, Error>> + 'e, Error> {
316 let mut logger = QueryLogger::new(query, self.inner.log_settings.clone());
317 let sql = logger.sql().as_str();
318
319 self.wait_until_ready().await?;
321
322 let (mut format, mut metadata) = self
323 .try_get_or_prepare(sql, arguments.as_mut(), persistent, metadata_opt.clone())
324 .await?;
325
326 let mut message = match self.inner.stream.recv().await {
327 Ok(msg) => msg,
328 Err(err) => {
329 if let Some(clear_backend_cache) = check_stale_plan(&err) {
330 let is_in_tx = self.in_transaction();
332
333 self.invalidate_cached_statement(sql, clear_backend_cache)
334 .await?;
335
336 if is_in_tx {
339 return Err(err);
340 }
341
342 (format, metadata) = self
344 .try_get_or_prepare(
345 sql,
346 arguments.as_mut(),
348 persistent,
349 metadata_opt.clone(),
350 )
351 .await?;
352
353 self.inner.stream.recv().await?
354 } else {
355 return Err(err);
356 }
357 }
358 };
359
360 Ok(try_stream! {
361 loop {
362 match message.format {
363 BackendMessageFormat::BindComplete
364 | BackendMessageFormat::ParseComplete
365 | BackendMessageFormat::ParameterDescription
366 | BackendMessageFormat::NoData
367 | BackendMessageFormat::CloseComplete
369 => {
370 }
372
373 BackendMessageFormat::CommandComplete => {
378 let cc: CommandComplete = message.decode()?;
380
381 let rows_affected = cc.rows_affected();
382 logger.increase_rows_affected(rows_affected);
383 r#yield!(Either::Left(PgQueryResult {
384 rows_affected,
385 }));
386 }
387
388 BackendMessageFormat::EmptyQueryResponse => {
389 }
391
392 BackendMessageFormat::PortalSuspended => {}
396
397 BackendMessageFormat::RowDescription => {
399 let (new_metadata, _) = self.resolve_statement_metadata::<false>(
400 None,
401 Some(message.decode()?),
402 false,
403 ).await?;
404
405 metadata = new_metadata;
406 }
407
408 BackendMessageFormat::DataRow => {
409 logger.increment_rows_returned();
410
411 let data: DataRow = message.decode()?;
413 let row = PgRow {
414 data,
415 format,
416 metadata: Arc::clone(&metadata),
417 };
418
419 r#yield!(Either::Right(row));
420 }
421
422 BackendMessageFormat::ReadyForQuery => {
423 self.handle_ready_for_query(message)?;
425 break;
426 }
427
428 _ => {
429 return Err(err_protocol!(
430 "execute: unexpected message: {:?}",
431 message.format
432 ));
433 }
434 }
435
436 message = self.inner.stream.recv().await?;
437 }
438
439 Ok(())
440 })
441 }
442}
443
444impl<'c> Executor<'c> for &'c mut PgConnection {
445 type Database = Postgres;
446
447 fn fetch_many<'e, 'q, E>(
448 self,
449 mut query: E,
450 ) -> BoxStream<'e, Result<Either<PgQueryResult, PgRow>, Error>>
451 where
452 'c: 'e,
453 E: Execute<'q, Self::Database>,
454 'q: 'e,
455 E: 'q,
456 {
457 #[allow(clippy::map_clone)]
459 let metadata = query.statement().map(|s| Arc::clone(&s.metadata));
460 let arguments = query.take_arguments().map_err(Error::Encode);
461 let persistent = query.persistent();
462 let sql = query.sql();
463
464 Box::pin(try_stream! {
465 let arguments = arguments?;
466 let mut s = pin!(self.run(sql, arguments, persistent, metadata).await?);
467
468 while let Some(v) = s.try_next().await? {
469 r#yield!(v);
470 }
471
472 Ok(())
473 })
474 }
475
476 fn fetch_optional<'e, 'q, E>(self, mut query: E) -> BoxFuture<'e, Result<Option<PgRow>, Error>>
477 where
478 'c: 'e,
479 E: Execute<'q, Self::Database>,
480 'q: 'e,
481 E: 'q,
482 {
483 #[allow(clippy::map_clone)]
485 let metadata = query.statement().map(|s| Arc::clone(&s.metadata));
486 let arguments = query.take_arguments().map_err(Error::Encode);
487 let persistent = query.persistent();
488
489 Box::pin(async move {
490 let sql = query.sql();
491 let arguments = arguments?;
492 let mut s = pin!(self.run(sql, arguments, persistent, metadata).await?);
493
494 let mut ret = None;
499 while let Some(result) = s.try_next().await? {
500 match result {
501 Either::Right(r) if ret.is_none() => ret = Some(r),
502 _ => {}
503 }
504 }
505 Ok(ret)
506 })
507 }
508
509 fn prepare_with<'e>(
510 self,
511 sql: SqlStr,
512 parameters: &'e [PgTypeInfo],
513 ) -> BoxFuture<'e, Result<PgStatement, Error>>
514 where
515 'c: 'e,
516 {
517 Box::pin(async move {
518 self.wait_until_ready().await?;
519
520 let (_, metadata) = self
521 .get_or_prepare(sql.as_str(), parameters, true, None, true)
522 .await?;
523
524 Ok(PgStatement { sql, metadata })
525 })
526 }
527
528 #[cfg(feature = "offline")]
529 fn describe<'e>(
530 self,
531 sql: SqlStr,
532 ) -> BoxFuture<'e, Result<crate::describe::Describe<Self::Database>, Error>>
533 where
534 'c: 'e,
535 {
536 Box::pin(async move {
537 self.wait_until_ready().await?;
538
539 let (stmt_id, metadata) = self
540 .get_or_prepare(sql.as_str(), &[], true, None, true)
541 .await?;
542
543 let nullable = self.get_nullable_for_columns(stmt_id, &metadata).await?;
544
545 Ok(crate::describe::Describe {
546 columns: metadata.columns.clone(),
547 nullable,
548 parameters: Some(Either::Left(metadata.parameters.clone())),
549 })
550 })
551 }
552}
553
554fn check_stale_plan(error: &Error) -> Option<bool> {
561 let error = error
562 .as_database_error()?
563 .try_downcast_ref::<PgDatabaseError>()?;
564
565 match (error.code(), error.routine()) {
566 ("0A000", Some("RevalidateCachedQuery")) => Some(true),
568 ("26000", _) => Some(false),
570 _ => None,
571 }
572}