Skip to main content

tank_postgres/
connection.rs

1use crate::{
2    PostgresDriver, PostgresPrepared, PostgresRows, PostgresStream, PostgresTransaction, ValueWrap,
3    util::{stream_postgres_simple_query_message_to_tank_query_result, value_to_postgres_type},
4};
5use async_stream::try_stream;
6use openssl::ssl::{SslConnector, SslFiletype, SslMethod, SslVerifyMode};
7use postgres_openssl::MakeTlsConnector;
8use postgres_types::ToSql;
9use std::{
10    borrow::Cow,
11    env,
12    iter::zip,
13    path::PathBuf,
14    pin::{Pin, pin},
15    str::FromStr,
16    sync::Arc,
17};
18use tank_core::{
19    AnyQuery, AsEntity, AsQuery, Connection, Driver, Entity, Error, ErrorContext, Executor, Query,
20    QueryResult, RawQuery, Result, Row, RowLabels, RowOwned, RowsAffected, SqlCoreWriter,
21    Transaction, describe_url,
22    stream::{Stream, StreamExt, TryStreamExt},
23    truncate_long,
24};
25use tokio::{spawn, task::JoinHandle};
26use tokio_postgres::{NoTls, binary_copy::BinaryCopyInWriter};
27
28/// PostgreSQL connection.
29#[derive(Debug)]
30pub struct PostgresConnection {
31    pub(crate) client: tokio_postgres::Client,
32    pub(crate) handle: JoinHandle<()>,
33    pub(crate) labels: RowLabels,
34}
35
36impl PostgresConnection {
37    #[cold]
38    #[inline(never)]
39    fn query_error(e: impl Into<Error>, query: &Query<PostgresDriver>) -> Error {
40        let error = e
41            .into()
42            .context(format!("While running the query:\n{query}"));
43        log::error!("{error:#}");
44        error
45    }
46
47    #[cold]
48    #[inline(never)]
49    fn rebuild_labels(labels: &mut RowLabels, columns: &[tokio_postgres::Column]) {
50        *labels = columns.iter().map(|c| c.name().to_string()).collect();
51    }
52
53    #[inline]
54    fn prepare_labels(labels: &mut RowLabels, columns: &[tokio_postgres::Column]) {
55        if columns.len() != labels.len()
56            || !zip(columns.iter(), labels.iter()).all(|(col, label)| col.name() == label)
57        {
58            Self::rebuild_labels(labels, columns);
59        }
60    }
61
62    #[inline]
63    async fn fetch_inner<'s>(
64        &'s mut self,
65        query: &mut Query<PostgresDriver>,
66    ) -> Result<PostgresRows<'s>> {
67        match query {
68            Query::Raw(RawQuery(sql)) => {
69                let mut stream = self
70                    .client
71                    .query_raw(sql.as_str(), Vec::<ValueWrap>::new())
72                    .await
73                    .map_err(|e| Self::query_error(e, query))?;
74                let first = std::future::poll_fn(|cx| {
75                    unsafe { Pin::new_unchecked(&mut stream) }.poll_next(cx)
76                })
77                .await
78                .transpose()
79                .map_err(|e| Self::query_error(e, query))?;
80                if let Some(ref row) = first {
81                    Self::prepare_labels(&mut self.labels, row.columns());
82                    Ok(PostgresRows::new(first, stream, &self.labels))
83                } else {
84                    // The pre-poll above drained a zero-row result: polling the
85                    // exhausted `RowStream` would yield `Error::closed()`.
86                    Ok(PostgresRows::new_drained(stream, &self.labels))
87                }
88            }
89            Query::Prepared(prepared) => {
90                let params = match prepared.take_params() {
91                    Ok(params) => params,
92                    Err(e) => return Err(Self::query_error(e, query)),
93                };
94                if !Arc::ptr_eq(&self.labels, &prepared.labels) {
95                    self.labels = prepared.labels.clone();
96                }
97                let stream = self
98                    .client
99                    .query_raw(&prepared.statement, params)
100                    .await
101                    .map_err(|e| Self::query_error(e, query))?;
102                Ok(PostgresRows::new(None, stream, &self.labels))
103            }
104        }
105    }
106}
107
108impl Executor for PostgresConnection {
109    type Driver = PostgresDriver;
110
111    async fn do_prepare(&mut self, sql: &str) -> Result<PostgresPrepared> {
112        let sql = sql.trim_end().trim_end_matches(';');
113        let statement = self
114            .client
115            .prepare(&sql)
116            .await
117            .with_context(|| format!("While preparing the query:\n{}", truncate_long(sql)))
118            .inspect_err(|e| log::error!("{e:#}"))?;
119        Ok(PostgresPrepared::new(statement))
120    }
121
122    fn run<'s>(
123        &'s mut self,
124        query: impl AsQuery<PostgresDriver> + 's,
125    ) -> impl Stream<Item = Result<QueryResult<impl Row + 's>>> + Send {
126        let mut query = query.as_query(&self.driver());
127        let context = format!("While running the query:\n{}", query.as_mut());
128        try_stream! {
129            // The raw variant streams without a transaction, borrow the caller's SQL so an
130            // abandoned stream leaves the query intact.
131            if let Query::Raw(RawQuery(sql)) = query.as_mut() {
132                let stream = stream_postgres_simple_query_message_to_tank_query_result(
133                    async move || self.client.simple_query_raw(sql.as_str()).await.map_err(Into::into),
134                );
135                let mut stream = pin!(stream);
136                while let Some(value) = stream.next().await.transpose()? {
137                    yield value;
138                }
139                return;
140            }
141            let mut transaction = self.begin().await?;
142            {
143                let mut stream = pin!(transaction.run(&mut *query.as_mut()));
144                while let Some(value) = stream.next().await.transpose()? {
145                    yield match value {
146                        QueryResult::Row(r) => QueryResult::Row(RowOwned::new(
147                            r.labels().into(),
148                            r.into_values().collect(),
149                        )),
150                        QueryResult::Affected(a) => QueryResult::Affected(a),
151                    };
152                }
153            }
154            transaction.commit().await?;
155        }
156        .map_err(move |e: Error| {
157            let error = e.context(context.clone());
158            log::error!("{error:#}");
159            error
160        })
161    }
162
163    fn fetch<'s>(
164        &'s mut self,
165        query: impl AsQuery<PostgresDriver> + 's,
166    ) -> impl Stream<Item = Result<impl Row + 's>> + Send {
167        let mut query = query.as_query(&self.driver());
168        PostgresStream::new(async move { self.fetch_inner(query.as_mut()).await })
169    }
170
171    async fn append<It>(&mut self, entities: It) -> Result<RowsAffected>
172    where
173        It: IntoIterator + Send,
174        It::IntoIter: Send,
175        It::Item: AsEntity,
176    {
177        type E<It> = <<It as IntoIterator>::Item as AsEntity>::Entity;
178        let mut iter = entities.into_iter();
179        let writer = self.driver().sql_writer();
180        let context = || {
181            format!(
182                "While appending to the table `{}`",
183                E::<It>::table().full_name(writer.separator())
184            )
185        };
186        let mut query = AnyQuery::default();
187        writer.write_copy(&mut query, E::<It>::table());
188        let sink = match self
189            .client
190            .copy_in(&query.as_str() as &str)
191            .await
192            .with_context(context)
193        {
194            Ok(v) => v,
195            Err(e) => {
196                log::error!("{e:#}");
197                return Err(e);
198            }
199        };
200        let types: Vec<_> = E::<It>::columns()
201            .into_iter()
202            .map(|c| value_to_postgres_type(&c.value))
203            .collect();
204        let writer = BinaryCopyInWriter::new(sink, &types);
205        let mut writer = pin!(writer);
206        let columns_len = E::<It>::columns().len();
207        let mut values = Vec::<ValueWrap>::with_capacity(columns_len);
208        let mut refs = Vec::<&(dyn ToSql + Sync)>::with_capacity(columns_len);
209        loop {
210            match iter.next() {
211                None => break,
212                Some(entity) => {
213                    // Owned, the values outlive `entity` across the write `.await`.
214                    values.extend(
215                        entity
216                            .as_entity()
217                            .row_values()
218                            .map(|v| ValueWrap(Cow::Owned(v.into_owned()))),
219                    );
220                }
221            }
222            refs.extend(
223                values
224                    .iter()
225                    .map(|v| unsafe { &*(v as &(dyn ToSql + Sync) as *const _) }),
226            );
227            match Pin::as_mut(&mut writer)
228                .write(&refs)
229                .await
230                .with_context(context)
231            {
232                Ok(_) => {}
233                Err(e) => {
234                    log::error!("{e:#}");
235                    return Err(e);
236                }
237            };
238            refs.clear();
239            values.clear();
240        }
241        match writer.finish().await.with_context(context) {
242            Ok(v) => Ok(RowsAffected {
243                rows_affected: Some(v),
244                last_affected_id: None,
245            }),
246            Err(e) => {
247                log::error!("{e:#}");
248                return Err(e);
249            }
250        }
251    }
252}
253
254impl Connection for PostgresConnection {
255    async fn connect(driver: &PostgresDriver, url: Cow<'static, str>) -> Result<Self> {
256        let mut url = Self::sanitize_url(driver, url)?;
257        let target = describe_url::<PostgresDriver>(&url);
258        let make_context = || format!(r#"Connecting to Postgres "{target}""#);
259        let mut take_url_param = |key: &str, env_var: &str, remove: bool| {
260            let value = url
261                .query_pairs()
262                .find_map(|(k, v)| if k == key { Some(v) } else { None })
263                .map(|v| v.to_string());
264            if remove && let Some(..) = value {
265                let mut result = url.clone();
266                result.set_query(None);
267                result
268                    .query_pairs_mut()
269                    .extend_pairs(url.query_pairs().filter(|(k, _)| k != key));
270                url = result;
271            };
272            value.or_else(|| env::var(env_var).ok().map(Into::into))
273        };
274        let sslmode = take_url_param("sslmode", "PGSSLMODE", false).unwrap_or("disable".into());
275        let (client, handle) = if sslmode == "disable" {
276            let (client, connection) = tokio_postgres::connect(url.as_str(), NoTls).await?;
277            let handle = spawn(async move {
278                if let Err(error) = connection.await
279                    && !error.is_closed()
280                {
281                    log::error!("Postgres connection error: {error:#?}");
282                }
283            });
284            (client, handle)
285        } else {
286            let mut builder = SslConnector::builder(SslMethod::tls())?;
287            let path = PathBuf::from_str(
288                take_url_param("sslrootcert", "PGSSLROOTCERT", true)
289                    .as_deref()
290                    .unwrap_or("~/.postgresql/root.crt"),
291            )
292            .context(make_context())?;
293            if path.exists() {
294                builder.set_ca_file(path)?;
295            }
296            let path = PathBuf::from_str(
297                take_url_param("sslcert", "PGSSLCERT", true)
298                    .as_deref()
299                    .unwrap_or("~/.postgresql/postgresql.crt"),
300            )
301            .context(make_context())?;
302            if path.exists() {
303                builder.set_certificate_chain_file(path)?;
304            }
305            let path = PathBuf::from_str(
306                take_url_param("sslkey", "PGSSLKEY", true)
307                    .as_deref()
308                    .unwrap_or("~/.postgresql/postgresql.key"),
309            )
310            .context(make_context())?;
311            if path.exists() {
312                builder.set_private_key_file(path, SslFiletype::PEM)?;
313            }
314            builder.set_verify(SslVerifyMode::PEER);
315            let connector = MakeTlsConnector::new(builder.build());
316            let (client, connection) = tokio_postgres::connect(url.as_str(), connector).await?;
317            let handle = spawn(async move {
318                if let Err(error) = connection.await
319                    && !error.is_closed()
320                {
321                    log::error!("Postgres connection error: {:#?}", error);
322                }
323            });
324            (client, handle)
325        };
326        Ok(Self {
327            client,
328            handle,
329            labels: Default::default(),
330        })
331    }
332
333    fn begin(&mut self) -> impl Future<Output = Result<PostgresTransaction<'_>>> + Send {
334        PostgresTransaction::new(self)
335    }
336
337    async fn disconnect(self) -> Result<()> {
338        drop(self.client);
339        if let Err(e) = self.handle.await {
340            let error = Error::new(e).context("While disconnecting from Postgres");
341            log::error!("{error:#}");
342            return Err(error);
343        }
344        Ok(())
345    }
346}