use std::collections::HashMap;
use std::sync::Arc;
use futures_util::{SinkExt, StreamExt};
use sha2::{Digest, Sha256};
use tokio::net::TcpStream;
use tokio_util::codec::Framed;
use crate::connections::server::ServerConn;
use crate::pool::PoolManager;
use crate::pool::prepared::StatementStore;
use crate::proto;
use crate::proto::frontend::Parse;
#[doc(hidden)]
pub fn canonical_for_test(query: &str, param_types: &[u32]) -> String {
canonical_name(query, param_types)
}
fn canonical_name(query: &str, param_types: &[u32]) -> String {
let mut hasher = Sha256::new();
hasher.update(query.as_bytes());
for &oid in param_types {
hasher.update(oid.to_le_bytes());
}
let hash = hasher.finalize();
format!(
"_hp_{:016x}",
u64::from_le_bytes(
hash[..8]
.try_into()
.expect("SHA-256 produces at least 8 bytes"),
)
)
}
#[derive(Default)]
pub struct ClientPrepared {
names: HashMap<String, String>,
}
impl ClientPrepared {
pub fn new() -> Self {
Self::default()
}
pub fn register(&mut self, parse: &Parse, store: &mut StatementStore) -> String {
let canon = canonical_name(&parse.query, &parse.param_types);
match self.names.insert(parse.name.clone(), canon.clone()) {
Some(ref old_canon) if old_canon == &canon => {
}
Some(old_canon) => {
store.add_ref(canon.clone(), parse.clone());
store.release(&old_canon);
}
None => {
store.add_ref(canon.clone(), parse.clone());
}
}
canon
}
pub fn resolve(&self, client_name: &str) -> Option<&str> {
self.names.get(client_name).map(String::as_str)
}
pub fn remove(&mut self, client_name: &str, store: &mut StatementStore) {
if let Some(canon) = self.names.remove(client_name) {
store.release(&canon);
}
}
pub fn release_all(&mut self, store: &mut StatementStore) {
for canon in self.names.values() {
store.release(canon);
}
self.names.clear();
}
}
pub(super) async fn rewrite_outbound(
msg: proto::frontend::FrontendMessage,
client_prepared: &mut ClientPrepared,
server: &mut ServerConn,
pools: &Arc<PoolManager>,
client: &mut Framed<TcpStream, proto::codec::FrontendCodec>,
) -> anyhow::Result<Option<proto::frontend::FrontendMessage>> {
match msg {
proto::frontend::FrontendMessage::Parse(parse) => {
let canon = {
let mut store = pools.stmt_store.lock();
client_prepared.register(&parse, &mut store)
};
ensure_prepared(&canon, server, pools).await?;
client
.send(proto::backend::BackendMessage::ParseComplete)
.await?;
Ok(None)
}
proto::frontend::FrontendMessage::Bind(mut bind) => {
if let Some(canon) = client_prepared.resolve(&bind.statement) {
ensure_prepared(canon, server, pools).await?;
bind.statement = canon.to_owned();
}
Ok(Some(proto::frontend::FrontendMessage::Bind(bind)))
}
proto::frontend::FrontendMessage::Describe(mut desc) => {
if desc.kind == proto::frontend::TargetKind::Statement
&& let Some(canon) = client_prepared.resolve(&desc.name)
{
ensure_prepared(canon, server, pools).await?;
desc.name = canon.to_owned();
}
Ok(Some(proto::frontend::FrontendMessage::Describe(desc)))
}
other => Ok(Some(other)),
}
}
async fn ensure_prepared(
canon: &str,
server: &mut ServerConn,
pools: &Arc<PoolManager>,
) -> anyhow::Result<()> {
if server.prepared.contains(canon) {
server.prepared.touch(canon);
return Ok(());
}
let stored_parse = {
let store = pools.stmt_store.lock();
store.get(canon).cloned()
};
let Some(mut parse) = stored_parse else {
anyhow::bail!("no stored Parse for canonical statement {canon}");
};
if let Some(evicted) = server.prepared.insert(canon.to_owned()) {
server
.framed
.send(proto::frontend::FrontendMessage::Close(
proto::frontend::Close {
kind: proto::frontend::TargetKind::Statement,
name: evicted,
},
))
.await?;
server
.framed
.send(proto::frontend::FrontendMessage::Sync)
.await?;
drain_until_ready(&mut server.framed).await?;
}
parse.name = canon.to_owned();
server
.framed
.send(proto::frontend::FrontendMessage::Parse(parse))
.await?;
server
.framed
.send(proto::frontend::FrontendMessage::Sync)
.await?;
drain_until_ready(&mut server.framed).await?;
Ok(())
}
async fn drain_until_ready(
framed: &mut Framed<TcpStream, proto::codec::BackendCodec>,
) -> anyhow::Result<()> {
loop {
match framed.next().await.transpose()? {
Some(proto::backend::BackendMessage::ReadyForQuery(_)) => return Ok(()),
Some(proto::backend::BackendMessage::ErrorResponse(err)) => {
anyhow::bail!(
"server error during prepared statement management: {}",
err.message().unwrap_or("unknown")
);
}
Some(_) => {} None => anyhow::bail!("upstream closed during prepared statement management"),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn canonical_name_deterministic() {
let a = canonical_name("SELECT 1", &[]);
let b = canonical_name("SELECT 1", &[]);
assert_eq!(a, b);
assert!(a.starts_with("_hp_"));
}
#[test]
fn canonical_name_differs_by_query() {
let a = canonical_name("SELECT 1", &[]);
let b = canonical_name("SELECT 2", &[]);
assert_ne!(a, b);
}
#[test]
fn canonical_name_differs_by_params() {
let a = canonical_name("SELECT $1", &[23]); let b = canonical_name("SELECT $1", &[25]); assert_ne!(a, b);
}
#[test]
fn client_register_and_resolve() {
let mut store = StatementStore::new();
let mut client = ClientPrepared::new();
let parse = Parse {
name: "my_stmt".into(),
query: "SELECT 1".into(),
param_types: vec![],
};
let canon = client.register(&parse, &mut store);
assert_eq!(client.resolve("my_stmt"), Some(canon.as_str()));
assert!(store.get(&canon).is_some());
}
#[test]
fn client_unnamed_tracked() {
let mut store = StatementStore::new();
let mut client = ClientPrepared::new();
let parse = Parse {
name: String::new(),
query: "SELECT 1".into(),
param_types: vec![],
};
let canon = client.register(&parse, &mut store);
assert_eq!(client.resolve(""), Some(canon.as_str()));
assert!(store.get(&canon).is_some());
}
#[test]
fn client_unnamed_replaced_by_new_parse() {
let mut store = StatementStore::new();
let mut client = ClientPrepared::new();
let parse1 = Parse {
name: String::new(),
query: "SELECT 1".into(),
param_types: vec![],
};
let parse2 = Parse {
name: String::new(),
query: "SELECT 2".into(),
param_types: vec![],
};
let canon1 = client.register(&parse1, &mut store);
let canon2 = client.register(&parse2, &mut store);
assert_ne!(canon1, canon2);
assert_eq!(client.resolve(""), Some(canon2.as_str()));
assert!(store.get(&canon1).is_none());
assert!(store.get(&canon2).is_some());
}
#[test]
fn reparse_same_query_does_not_leak_refcount() {
let mut store = StatementStore::new();
let mut client = ClientPrepared::new();
let parse = Parse {
name: String::new(),
query: "SELECT 1".into(),
param_types: vec![],
};
let canon = client.register(&parse, &mut store);
client.register(&parse, &mut store);
client.register(&parse, &mut store);
client.release_all(&mut store);
assert!(
store.get(&canon).is_none(),
"store entry should be gone after release_all, but refcount leaked"
);
}
#[test]
fn client_remove() {
let mut store = StatementStore::new();
let mut client = ClientPrepared::new();
let parse = Parse {
name: "s1".into(),
query: "SELECT 1".into(),
param_types: vec![],
};
client.register(&parse, &mut store);
assert!(client.resolve("s1").is_some());
client.remove("s1", &mut store);
assert!(client.resolve("s1").is_none());
}
#[test]
fn deduplication_across_clients() {
let mut store = StatementStore::new();
let mut client_a = ClientPrepared::new();
let mut client_b = ClientPrepared::new();
let parse_a = Parse {
name: "s1".into(),
query: "SELECT 1".into(),
param_types: vec![],
};
let parse_b = Parse {
name: "s1".into(),
query: "SELECT 1".into(),
param_types: vec![],
};
let canon_a = client_a.register(&parse_a, &mut store);
let canon_b = client_b.register(&parse_b, &mut store);
assert_eq!(canon_a, canon_b);
}
#[test]
fn no_collision_different_queries_same_client_name() {
let mut store = StatementStore::new();
let mut client_a = ClientPrepared::new();
let mut client_b = ClientPrepared::new();
let parse_a = Parse {
name: "s1".into(),
query: "SELECT 1".into(),
param_types: vec![],
};
let parse_b = Parse {
name: "s1".into(),
query: "SELECT 2".into(),
param_types: vec![],
};
let canon_a = client_a.register(&parse_a, &mut store);
let canon_b = client_b.register(&parse_b, &mut store);
assert_ne!(canon_a, canon_b);
}
#[test]
fn store_refcount_cleanup() {
let mut store = StatementStore::new();
let mut client_a = ClientPrepared::new();
let mut client_b = ClientPrepared::new();
let parse = Parse {
name: "s1".into(),
query: "SELECT 1".into(),
param_types: vec![],
};
let canon = client_a.register(&parse, &mut store);
client_b.register(&parse, &mut store);
assert!(store.get(&canon).is_some());
client_a.release_all(&mut store);
assert!(store.get(&canon).is_some());
client_b.release_all(&mut store);
assert!(store.get(&canon).is_none());
}
#[test]
fn remove_decrements_refcount() {
let mut store = StatementStore::new();
let mut client = ClientPrepared::new();
let parse = Parse {
name: "s1".into(),
query: "SELECT 1".into(),
param_types: vec![],
};
let canon = client.register(&parse, &mut store);
assert!(store.get(&canon).is_some());
client.remove("s1", &mut store);
assert!(store.get(&canon).is_none());
}
}