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#[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 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 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 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}