1use std::collections::HashMap;
23use std::sync::Arc;
24
25use futures_util::SinkExt;
26use sha2::{Digest, Sha256};
27use tokio::net::TcpStream;
28use tokio_util::codec::Framed;
29
30use crate::connections::server::{ClientParse, Reprepare, ServerConn};
31use crate::pool::PoolManager;
32use crate::pool::prepared::StatementStore;
33use crate::proto;
34use crate::proto::frontend::Parse;
35
36#[doc(hidden)]
43pub fn canonical_for_test(query: &str, param_types: &[u32]) -> String {
44 canonical_name(query, param_types)
45}
46
47fn canonical_name(query: &str, param_types: &[u32]) -> String {
51 let mut hasher = Sha256::new();
52 hasher.update(query.as_bytes());
53 for &oid in param_types {
54 hasher.update(oid.to_le_bytes());
55 }
56 let hash = hasher.finalize();
57 format!(
58 "_hp_{:016x}",
59 u64::from_le_bytes(
60 hash[..8]
61 .try_into()
62 .expect("SHA-256 produces at least 8 bytes"),
63 )
64 )
65}
66
67#[derive(Default)]
73pub struct ClientPrepared {
74 names: HashMap<String, String>,
76}
77
78impl ClientPrepared {
79 pub fn new() -> Self {
80 Self::default()
81 }
82
83 pub fn register(&mut self, parse: &Parse, store: &mut StatementStore) -> String {
89 let canon = canonical_name(&parse.query, &parse.param_types);
90 match self.names.insert(parse.name.clone(), canon.clone()) {
91 Some(ref old_canon) if old_canon == &canon => {
92 }
94 Some(old_canon) => {
95 store.add_ref(canon.clone(), parse.clone());
96 store.release(&old_canon);
97 }
98 None => {
99 store.add_ref(canon.clone(), parse.clone());
100 }
101 }
102 canon
103 }
104
105 pub fn resolve(&self, client_name: &str) -> Option<&str> {
109 self.names.get(client_name).map(String::as_str)
110 }
111
112 pub fn remove(&mut self, client_name: &str, store: &mut StatementStore) {
114 if let Some(canon) = self.names.remove(client_name) {
115 store.release(&canon);
116 }
117 }
118
119 pub fn release_all(&mut self, store: &mut StatementStore) {
122 for canon in self.names.values() {
123 store.release(canon);
124 }
125 self.names.clear();
126 }
127}
128
129pub(super) struct PreparedGuard {
134 pub(super) inner: ClientPrepared,
135 pub(super) pools: Arc<PoolManager>,
136}
137
138impl Drop for PreparedGuard {
139 fn drop(&mut self) {
140 let mut store = self.pools.stmt_store.lock();
141 self.inner.release_all(&mut store);
142 }
143}
144
145pub(super) async fn rewrite_outbound(
155 msg: proto::frontend::FrontendMessage,
156 client_prepared: &mut ClientPrepared,
157 server: &mut ServerConn,
158 pools: &Arc<PoolManager>,
159 client: &mut Framed<TcpStream, proto::codec::FrontendCodec>,
160) -> anyhow::Result<Option<proto::frontend::FrontendMessage>> {
161 match msg {
162 proto::frontend::FrontendMessage::Parse(parse) => {
163 let canon = {
164 let mut store = pools.stmt_store.lock();
165 client_prepared.register(&parse, &mut store)
166 };
167
168 match server.statements.note_client_parse(&canon) {
169 ClientParse::Synthesize => {
170 client
177 .send(proto::backend::BackendMessage::ParseComplete)
178 .await?;
179 Ok(None)
180 }
181 ClientParse::Forward { eviction } => {
182 send_eviction(eviction, server).await?;
187 let mut parse = parse;
188 parse.name = canon;
189 Ok(Some(proto::frontend::FrontendMessage::Parse(parse)))
190 }
191 }
192 }
193
194 proto::frontend::FrontendMessage::Bind(mut bind) => {
195 if let Some(canon) = client_prepared.resolve(&bind.statement) {
196 ensure_prepared(canon, server, pools).await?;
197 bind.statement = canon.to_owned();
198 }
199 Ok(Some(proto::frontend::FrontendMessage::Bind(bind)))
200 }
201
202 proto::frontend::FrontendMessage::Describe(mut desc) => {
203 if desc.kind == proto::frontend::TargetKind::Statement
204 && let Some(canon) = client_prepared.resolve(&desc.name)
205 {
206 ensure_prepared(canon, server, pools).await?;
207 desc.name = canon.to_owned();
208 }
209 Ok(Some(proto::frontend::FrontendMessage::Describe(desc)))
210 }
211
212 proto::frontend::FrontendMessage::Close(close) => {
213 server.statements.note_portal_close();
219 Ok(Some(proto::frontend::FrontendMessage::Close(close)))
220 }
221
222 other => Ok(Some(other)),
223 }
224}
225
226async fn ensure_prepared(
242 canon: &str,
243 server: &mut ServerConn,
244 pools: &Arc<PoolManager>,
245) -> anyhow::Result<()> {
246 match server.statements.note_reprepare(canon) {
247 Reprepare::AlreadyPrepared => Ok(()),
248 Reprepare::Prepare { eviction } => {
249 let stored_parse = {
255 let store = pools.stmt_store.lock();
256 store.get(canon).cloned()
257 };
258 let Some(mut parse) = stored_parse else {
259 anyhow::bail!("no stored Parse for canonical statement {canon}");
260 };
261 send_eviction(eviction, server).await?;
262 parse.name = canon.to_owned();
263 server
264 .framed
265 .send(proto::frontend::FrontendMessage::Parse(parse))
266 .await?;
267 Ok(())
268 }
269 }
270}
271
272async fn send_eviction(eviction: Option<String>, server: &mut ServerConn) -> anyhow::Result<()> {
278 if let Some(evicted) = eviction {
279 server
280 .framed
281 .send(proto::frontend::FrontendMessage::Close(
282 proto::frontend::Close {
283 kind: proto::frontend::TargetKind::Statement,
284 name: evicted,
285 },
286 ))
287 .await?;
288 }
289 Ok(())
290}
291
292#[cfg(test)]
297mod tests {
298 use super::*;
299
300 #[test]
301 fn canonical_name_deterministic() {
302 let a = canonical_name("SELECT 1", &[]);
303 let b = canonical_name("SELECT 1", &[]);
304 assert_eq!(a, b);
305 assert!(a.starts_with("_hp_"));
306 }
307
308 #[test]
309 fn canonical_name_differs_by_query() {
310 let a = canonical_name("SELECT 1", &[]);
311 let b = canonical_name("SELECT 2", &[]);
312 assert_ne!(a, b);
313 }
314
315 #[test]
316 fn canonical_name_differs_by_params() {
317 let a = canonical_name("SELECT $1", &[23]); let b = canonical_name("SELECT $1", &[25]); assert_ne!(a, b);
320 }
321
322 #[test]
323 fn client_register_and_resolve() {
324 let mut store = StatementStore::new();
325 let mut client = ClientPrepared::new();
326
327 let parse = Parse {
328 name: "my_stmt".into(),
329 query: "SELECT 1".into(),
330 param_types: vec![],
331 };
332
333 let canon = client.register(&parse, &mut store);
334 assert_eq!(client.resolve("my_stmt"), Some(canon.as_str()));
335 assert!(store.get(&canon).is_some());
336 }
337
338 #[test]
339 fn client_unnamed_tracked() {
340 let mut store = StatementStore::new();
341 let mut client = ClientPrepared::new();
342
343 let parse = Parse {
344 name: String::new(),
345 query: "SELECT 1".into(),
346 param_types: vec![],
347 };
348
349 let canon = client.register(&parse, &mut store);
350 assert_eq!(client.resolve(""), Some(canon.as_str()));
351 assert!(store.get(&canon).is_some());
352 }
353
354 #[test]
355 fn client_unnamed_replaced_by_new_parse() {
356 let mut store = StatementStore::new();
357 let mut client = ClientPrepared::new();
358
359 let parse1 = Parse {
360 name: String::new(),
361 query: "SELECT 1".into(),
362 param_types: vec![],
363 };
364 let parse2 = Parse {
365 name: String::new(),
366 query: "SELECT 2".into(),
367 param_types: vec![],
368 };
369
370 let canon1 = client.register(&parse1, &mut store);
371 let canon2 = client.register(&parse2, &mut store);
372 assert_ne!(canon1, canon2);
373
374 assert_eq!(client.resolve(""), Some(canon2.as_str()));
376 assert!(store.get(&canon1).is_none());
378 assert!(store.get(&canon2).is_some());
379 }
380
381 #[test]
382 fn reparse_same_query_does_not_leak_refcount() {
383 let mut store = StatementStore::new();
384 let mut client = ClientPrepared::new();
385
386 let parse = Parse {
387 name: String::new(),
388 query: "SELECT 1".into(),
389 param_types: vec![],
390 };
391
392 let canon = client.register(&parse, &mut store);
393 client.register(&parse, &mut store);
395 client.register(&parse, &mut store);
396
397 client.release_all(&mut store);
399 assert!(
400 store.get(&canon).is_none(),
401 "store entry should be gone after release_all, but refcount leaked"
402 );
403 }
404
405 #[test]
406 fn client_remove() {
407 let mut store = StatementStore::new();
408 let mut client = ClientPrepared::new();
409
410 let parse = Parse {
411 name: "s1".into(),
412 query: "SELECT 1".into(),
413 param_types: vec![],
414 };
415
416 client.register(&parse, &mut store);
417 assert!(client.resolve("s1").is_some());
418 client.remove("s1", &mut store);
419 assert!(client.resolve("s1").is_none());
420 }
421
422 #[test]
423 fn deduplication_across_clients() {
424 let mut store = StatementStore::new();
425 let mut client_a = ClientPrepared::new();
426 let mut client_b = ClientPrepared::new();
427
428 let parse_a = Parse {
429 name: "s1".into(),
430 query: "SELECT 1".into(),
431 param_types: vec![],
432 };
433 let parse_b = Parse {
434 name: "s1".into(),
435 query: "SELECT 1".into(),
436 param_types: vec![],
437 };
438
439 let canon_a = client_a.register(&parse_a, &mut store);
440 let canon_b = client_b.register(&parse_b, &mut store);
441
442 assert_eq!(canon_a, canon_b);
444 }
445
446 #[test]
447 fn no_collision_different_queries_same_client_name() {
448 let mut store = StatementStore::new();
449 let mut client_a = ClientPrepared::new();
450 let mut client_b = ClientPrepared::new();
451
452 let parse_a = Parse {
453 name: "s1".into(),
454 query: "SELECT 1".into(),
455 param_types: vec![],
456 };
457 let parse_b = Parse {
458 name: "s1".into(),
459 query: "SELECT 2".into(),
460 param_types: vec![],
461 };
462
463 let canon_a = client_a.register(&parse_a, &mut store);
464 let canon_b = client_b.register(&parse_b, &mut store);
465
466 assert_ne!(canon_a, canon_b);
468 }
469
470 #[test]
471 fn store_refcount_cleanup() {
472 let mut store = StatementStore::new();
473 let mut client_a = ClientPrepared::new();
474 let mut client_b = ClientPrepared::new();
475
476 let parse = Parse {
477 name: "s1".into(),
478 query: "SELECT 1".into(),
479 param_types: vec![],
480 };
481
482 let canon = client_a.register(&parse, &mut store);
483 client_b.register(&parse, &mut store);
484
485 assert!(store.get(&canon).is_some());
487
488 client_a.release_all(&mut store);
490 assert!(store.get(&canon).is_some());
491
492 client_b.release_all(&mut store);
494 assert!(store.get(&canon).is_none());
495 }
496
497 #[test]
498 fn remove_decrements_refcount() {
499 let mut store = StatementStore::new();
500 let mut client = ClientPrepared::new();
501
502 let parse = Parse {
503 name: "s1".into(),
504 query: "SELECT 1".into(),
505 param_types: vec![],
506 };
507
508 let canon = client.register(&parse, &mut store);
509 assert!(store.get(&canon).is_some());
510
511 client.remove("s1", &mut store);
512 assert!(store.get(&canon).is_none());
514 }
515}