sqlx_postgres/connection/
mod.rs1use std::collections::BTreeMap;
2use std::fmt::{self, Debug, Formatter};
3use std::future::Future;
4use std::sync::Arc;
5
6use crate::HashMap;
7
8use crate::common::StatementCache;
9use crate::error::Error;
10use crate::ext::ustr::UStr;
11use crate::io::StatementId;
12use crate::message::{
13 BackendMessageFormat, Close, Query, ReadyForQuery, ReceivedMessage, Terminate,
14 TransactionStatus,
15};
16use crate::statement::PgStatementMetadata;
17use crate::transaction::Transaction;
18use crate::types::Oid;
19use crate::{PgConnectOptions, PgTypeInfo, Postgres};
20
21pub(crate) use sqlx_core::connection::*;
22use sqlx_core::sql_str::SqlSafeStr;
23
24pub use self::stream::PgStream;
25
26#[cfg(feature = "offline")]
27mod describe;
28mod establish;
29mod executor;
30mod resolve;
31mod sasl;
32mod stream;
33mod tls;
34
35pub struct PgConnection {
39 pub(crate) inner: Box<PgConnectionInner>,
40}
41
42pub struct PgConnectionInner {
43 pub(crate) stream: PgStream,
47
48 #[allow(dead_code)]
51 process_id: u32,
52
53 #[allow(dead_code)]
56 secret_key: u32,
57
58 next_statement_id: StatementId,
61
62 cache_statement: StatementCache<(StatementId, Arc<PgStatementMetadata>)>,
64
65 cache_type_info: HashMap<Oid, PgTypeInfo>,
67 cache_type_oid: HashMap<UStr, Oid>,
68 cache_elem_type_to_array: HashMap<Oid, Oid>,
69 cache_table_data: HashMap<Oid, TableData>,
70
71 pub(crate) pending_ready_for_query_count: usize,
73
74 transaction_status: TransactionStatus,
76 pub(crate) transaction_depth: usize,
77
78 log_settings: LogSettings,
79}
80
81pub(crate) struct TableData {
82 table_name: Arc<str>,
83 columns: BTreeMap<i16, Arc<str>>,
85}
86
87impl PgConnection {
88 pub fn server_version_num(&self) -> Option<u32> {
90 self.inner.stream.server_version_num
91 }
92
93 pub(crate) async fn wait_until_ready(&mut self) -> Result<(), Error> {
95 if !self.inner.stream.write_buffer_mut().is_empty() {
96 self.inner.stream.flush().await?;
97 }
98
99 while self.inner.pending_ready_for_query_count > 0 {
100 let message = self.inner.stream.recv().await?;
101
102 if let BackendMessageFormat::ReadyForQuery = message.format {
103 self.handle_ready_for_query(message)?;
104 }
105 }
106
107 Ok(())
108 }
109
110 async fn recv_ready_for_query(&mut self) -> Result<(), Error> {
111 let r: ReadyForQuery = self.inner.stream.recv_expect().await?;
112
113 self.inner.pending_ready_for_query_count -= 1;
114 self.inner.transaction_status = r.transaction_status;
115
116 Ok(())
117 }
118
119 #[inline(always)]
120 fn handle_ready_for_query(&mut self, message: ReceivedMessage) -> Result<(), Error> {
121 self.inner.pending_ready_for_query_count = self
122 .inner
123 .pending_ready_for_query_count
124 .checked_sub(1)
125 .ok_or_else(|| err_protocol!("received more ReadyForQuery messages than expected"))?;
126
127 self.inner.transaction_status = message.decode::<ReadyForQuery>()?.transaction_status;
128
129 Ok(())
130 }
131
132 #[inline(always)]
136 pub(crate) fn queue_simple_query(&mut self, query: &str) -> Result<(), Error> {
137 self.inner.stream.write_msg(Query(query))?;
138 self.inner.pending_ready_for_query_count += 1;
139
140 Ok(())
141 }
142
143 pub(crate) fn in_transaction(&self) -> bool {
144 match self.inner.transaction_status {
145 TransactionStatus::Transaction => true,
146 TransactionStatus::Error | TransactionStatus::Idle => false,
147 }
148 }
149
150 pub(crate) async fn invalidate_cached_statement(
151 &mut self,
152 sql: &str,
153 backend: bool,
154 ) -> Result<(), Error> {
155 self.wait_until_ready().await?;
156
157 let Some((statement_id, _)) = self.inner.cache_statement.remove(sql) else {
158 return Ok(());
159 };
160
161 if backend {
162 self.inner
163 .stream
164 .write_msg(Close::Statement(statement_id))?;
165 self.write_sync();
166 self.inner.stream.flush().await?;
167
168 self.wait_for_close_complete(1).await?;
169 self.recv_ready_for_query().await?;
170 }
171
172 Ok(())
173 }
174}
175
176impl Debug for PgConnection {
177 fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
178 f.debug_struct("PgConnection").finish()
179 }
180}
181
182impl Connection for PgConnection {
183 type Database = Postgres;
184
185 type Options = PgConnectOptions;
186
187 async fn close(mut self) -> Result<(), Error> {
188 self.inner.stream.send(Terminate).await?;
194 self.inner.stream.shutdown().await?;
195
196 Ok(())
197 }
198
199 async fn close_hard(mut self) -> Result<(), Error> {
200 self.inner.stream.shutdown().await?;
201
202 Ok(())
203 }
204
205 async fn ping(&mut self) -> Result<(), Error> {
206 self.write_sync();
212 self.wait_until_ready().await
213 }
214
215 fn begin(
216 &mut self,
217 ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_ {
218 Transaction::begin(self, None)
219 }
220
221 fn begin_with(
222 &mut self,
223 statement: impl SqlSafeStr,
224 ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
225 where
226 Self: Sized,
227 {
228 Transaction::begin(self, Some(statement.into_sql_str()))
229 }
230
231 fn cached_statements_size(&self) -> usize {
232 self.inner.cache_statement.len()
233 }
234
235 async fn clear_cached_statements(&mut self) -> Result<(), Error> {
236 self.inner.cache_type_oid.clear();
237
238 let mut cleared = 0_usize;
239
240 self.wait_until_ready().await?;
241
242 while let Some((id, _)) = self.inner.cache_statement.remove_lru() {
243 self.inner.stream.write_msg(Close::Statement(id))?;
244 cleared += 1;
245 }
246
247 if cleared > 0 {
248 self.write_sync();
249 self.inner.stream.flush().await?;
250
251 self.wait_for_close_complete(cleared).await?;
252 self.recv_ready_for_query().await?;
253 }
254
255 Ok(())
256 }
257
258 fn shrink_buffers(&mut self) {
259 self.inner.stream.shrink_buffers();
260 }
261
262 #[doc(hidden)]
263 fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_ {
264 self.wait_until_ready()
265 }
266
267 #[doc(hidden)]
268 fn should_flush(&self) -> bool {
269 !self.inner.stream.write_buffer().is_empty()
270 }
271}
272
273impl AsMut<PgConnection> for PgConnection {
278 fn as_mut(&mut self) -> &mut PgConnection {
279 self
280 }
281}