Sep 20, 2025 · Jul 2, 2025 · Jul 2, 2025 · Jul 2, 2025
diff --git a/codegen/src/sqlstate.rs b/codegen/src/sqlstate.rs
            file,
            r#"
            Inner::E{code} => "{code}","#,
            code = code,
        )
        .unwrap();
    }
    /// {code}
    pub const {name}: SqlState = SqlState(Inner::E{code});
 "#,
                name = name,
                code = code,
            )
            .unwrap();
        }
        write!(
            file,
            r#"
    E{},"#,
            code,
    E{code},"#,
        )
        .unwrap();
    }
diff --git a/codegen/src/type_gen.rs b/codegen/src/type_gen.rs
        let doc_name = array_re.replace(&name, "$1[]").to_ascii_uppercase();
        let mut doc = doc_name.clone();
        if let Some(descr) = raw_type.get("descr") {
            write!(doc, " - {}", descr).unwrap();
            write!(doc, " - {descr}").unwrap();
        }
        let doc = Escape::new(doc.as_bytes().iter().cloned()).collect();
        let doc = String::from_utf8(doc).unwrap();

        if let Some(array_type_oid) = raw_type.get("array_type_oid") {
            let array_type_oid = array_type_oid.parse::<u32>().unwrap();

            let name = format!("_{}", name);
            let variant = format!("{}Array", variant);
            let doc = format!("{}&#91;&#93;", doc_name);
            let ident = format!("{}_ARRAY", ident);
            let name = format!("_{name}");
            let variant = format!("{variant}Array");
            let doc = format!("{doc_name}&#91;&#93;");
            let ident = format!("{ident}_ARRAY");

            let type_ = Type {
                name,
diff --git a/postgres-derive-test/src/lib.rs b/postgres-derive-test/src/lib.rs
        let result = conn.query_one(&stmt, &[]).unwrap().get(0);
        assert_eq!(val, &result);

        let stmt = conn.prepare(&format!("SELECT $1::{}", sql_type)).unwrap();
        let stmt = conn.prepare(&format!("SELECT $1::{sql_type}")).unwrap();
        let result = conn.query_one(&stmt, &[val]).unwrap().get(0);
        assert_eq!(val, &result);
    }
        let result: F = conn.query_one(&stmt, &[]).unwrap().get(0);
        assert!(cmp(val, &result));

        let stmt = conn.prepare(&format!("SELECT $1::{}", sql_type)).unwrap();
        let stmt = conn.prepare(&format!("SELECT $1::{sql_type}")).unwrap();
        let result: F = conn.query_one(&stmt, &[val]).unwrap().get(0);
        assert!(cmp(val, &result));
    }
diff --git a/postgres-derive/src/overrides.rs b/postgres-derive/src/overrides.rs
 "invalid rename_all rule, expected one of: {}",
 RENAME_RULES
 .iter()
 .map(|rule| format!("\"{}\"", rule))
 .map(|rule| format!("\"{rule}\""))
 .collect::<Vec<_>>()
 .join(", ")
 ),
diff --git a/postgres-derive/src/tosql.rs b/postgres-derive/src/tosql.rs
                postgres_types::IsNull::Yes => -1,
                postgres_types::IsNull::No =>{
 let len = buf.len() - base -4;
 if len >i32::max_value()asusize{
 if len >i32::MAXasusize{
 return std::result::Result::Err(
                            std::convert::Into::into("value too large to transmit"));
 }
diff --git a/postgres-protocol/src/authentication/mod.rs b/postgres-protocol/src/authentication/mod.rs
    md5.update(password);
    md5.update(username);
    let output = md5.finalize_reset();
    md5.update(format!("{:x}", output));
    md5.update(format!("{output:x}"));
    md5.update(salt);
    format!("md5{:x}", md5.finalize())
 }
diff --git a/postgres-protocol/src/authentication/sasl.rs b/postgres-protocol/src/authentication/sasl.rs

        let verifier = match parsed {
            ServerFinalMessage::Error(e) => {
                return Err(io::Error::other(format!("SCRAM error: {}", e)));
                return Err(io::Error::other(format!("SCRAM error: {e}")));
            }
            ServerFinalMessage::Verifier(verifier) => verifier,
        };
        match self.it.next() {
            Some((_, c)) if c == target => Ok(()),
            Some((i, c)) => {
                let m = format!(
                    "unexpected character at byte {}: expected `{}` but got `{}",
                    i, target, c
                );
                let m =
                    format!("unexpected character at byte {i}: expected `{target}` but got `{c}");
                Err(io::Error::new(io::ErrorKind::InvalidInput, m))
            }
            None => Err(io::Error::new(
        match self.it.peek() {
            Some(&(i, _)) => Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                format!("unexpected trailing data at byte {}", i),
                format!("unexpected trailing data at byte {i}"),
            )),
            None => Ok(()),
        }
diff --git a/postgres-protocol/src/message/backend.rs b/postgres-protocol/src/message/backend.rs
                tag => {
                    return Err(io::Error::new(
                        io::ErrorKind::InvalidInput,
                        format!("unknown authentication tag `{}`", tag),
                        format!("unknown authentication tag `{tag}`"),
                    ));
                }
            },
            tag => {
                return Err(io::Error::new(
                    io::ErrorKind::InvalidInput,
                    format!("unknown message tag `{}`", tag),
                    format!("unknown message tag `{tag}`"),
                ));
            }
        };
diff --git a/postgres-protocol/src/password/mod.rs b/postgres-protocol/src/password/mod.rs
 letmut hash =Md5::new();
    hash.update(&salted_password);
 let digest = hash.finalize();
 format!("md5{:x}", digest)
 format!("md5{digest:x}")
 }
diff --git a/postgres-types/src/chrono_04.rs b/postgres-types/src/chrono_04.rs
    DateTime, Duration, FixedOffset, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc,
 };
 use postgres_protocol::types;
 use std::error::Error;
 use std::{convert::TryFrom,error::Error};

 use crate::{FromSql, IsNull, ToSql, Type};

 impl ToSql for NaiveDate {
    fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
        let jd = self.signed_duration_since(base().date()).num_days();
        if jd > i64::from(i32::max_value()) || jd < i64::from(i32::min_value()) {
            return Err("value too large to transmit".into());
        }
        let jd = i32::try_from(jd).map_err(|_| "value too large to transmit")?;

        types::date_to_sql(jd as i32, w);
        types::date_to_sql(jd, w);
        Ok(IsNull::No)
    }

diff --git a/postgres-types/src/lib.rs b/postgres-types/src/lib.rs
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self.schema() {
            "public" | "pg_catalog" => {}
            schema => write!(fmt, "{}.", schema)?,
            schema => write!(fmt, "{schema}.")?,
        }
        fmt.write_str(self.name())
    }
            let v = values
                .next()?
                .ok_or_else(|| -> Box<dyn Error + Sync + Send> {
                    format!("too few elements in array (expected {}, got {})", N, i).into()
                    format!("too few elements in array (expected {N}, got {i})").into()
                })?;
            T::from_sql_nullable(member_type, v)
        })?;
        if values.next()?.is_some() {
            return Err(format!(
                "excess elements in array (expected {}, got more than that)",
                N,
            )
            .into());
            return Err(
                format!("excess elements in array (expected {N}, got more than that)",).into(),
            );
        }

        Ok(out)
diff --git a/postgres-types/src/pg_lsn.rs b/postgres-types/src/pg_lsn.rs

 impl fmt::Debug for PgLsn {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
 f.write_fmt(format_args!("{}", self))
 fmt::Display::fmt(self, f)
    }
 }

diff --git a/postgres-types/src/time_02.rs b/postgres-types/src/time_02.rs
 impl ToSql for Date {
    fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
        let jd = (*self - base().date()).whole_days();
        if jd > i64::from(i32::max_value()) || jd < i64::from(i32::min_value()) {
            return Err("value too large to transmit".into());
        }
        let jd = i32::try_from(jd).map_err(|_| "value too large to transmit")?;

        types::date_to_sql(jd as i32, w);
        types::date_to_sql(jd, w);
        Ok(IsNull::No)
    }

diff --git a/postgres-types/src/time_03.rs b/postgres-types/src/time_03.rs
 impl ToSql for Date {
    fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
        let jd = (*self - base().date()).whole_days();
        if jd > i64::from(i32::max_value()) || jd < i64::from(i32::min_value()) {
            return Err("value too large to transmit".into());
        }
        let jd = i32::try_from(jd).map_err(|_| "value too large to transmit")?;

        types::date_to_sql(jd as i32, w);
        types::date_to_sql(jd, w);
        Ok(IsNull::No)
    }

diff --git a/tokio-postgres/src/config.rs b/tokio-postgres/src/config.rs
        match self.it.next() {
            Some((_, c)) if c == target => Ok(()),
            Some((i, c)) => {
                let m = format!(
                    "unexpected character at byte {}: expected `{}` but got `{}`",
                    i, target, c
                );
                let m =
                    format!("unexpected character at byte {i}: expected `{target}` but got `{c}`");
                Err(Error::config_parse(m.into()))
            }
            None => Err(Error::config_parse("unexpected EOF".into())),
diff --git a/tokio-postgres/src/connect_socket.rs b/tokio-postgres/src/connect_socket.rs
        }
        #[cfg(unix)]
        Addr::Unix(dir) => {
            let path = dir.join(format!(".s.PGSQL.{}", port));
            let path = dir.join(format!(".s.PGSQL.{port}"));
            let socket = connect_with_timeout(UnixStream::connect(path), connect_timeout).await?;
            Ok(Socket::new_unix(socket))
        }
diff --git a/tokio-postgres/src/error/mod.rs b/tokio-postgres/src/error/mod.rs
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(fmt, "{}: {}", self.severity, self.message)?;
        if let Some(detail) = &self.detail {
            write!(fmt, "\nDETAIL: {}", detail)?;
            write!(fmt, "\nDETAIL: {detail}")?;
        }
        if let Some(hint) = &self.hint {
            write!(fmt, "\nHINT: {}", hint)?;
            write!(fmt, "\nHINT: {hint}")?;
        }
        Ok(())
    }
            Kind::Io => fmt.write_str("error communicating with the server")?,
            Kind::UnexpectedMessage => fmt.write_str("unexpected message from server")?,
            Kind::Tls => fmt.write_str("error performing TLS handshake")?,
            Kind::ToSql(idx) => write!(fmt, "error serializing parameter {}", idx)?,
            Kind::FromSql(idx) => write!(fmt, "error deserializing column {}", idx)?,
            Kind::Column(column) => write!(fmt, "invalid column `{}`", column)?,
            Kind::ToSql(idx) => write!(fmt, "error serializing parameter {idx}")?,
            Kind::FromSql(idx) => write!(fmt, "error deserializing column {idx}")?,
            Kind::Column(column) => write!(fmt, "invalid column `{column}`")?,
            Kind::Parameters(real, expected) => {
                write!(fmt, "expected {expected} parameters but got {real}")?
            }
            Kind::Timeout => fmt.write_str("timeout waiting for server")?,
        };
        if let Some(ref cause) = self.0.cause {
            write!(fmt, ": {}", cause)?;
            write!(fmt, ": {cause}")?;
        }
        Ok(())
    }
diff --git a/tokio-postgres/src/prepare.rs b/tokio-postgres/src/prepare.rs

 fn encode(client: &InnerClient, name: &str, query: &str, types: &[Type]) -> Result<Bytes, Error> {
    if types.is_empty() {
        debug!("preparing query {}: {}", name, query);
        debug!("preparing query {name}: {query}");
    } else {
        debug!("preparing query {} with types {:?}: {}", name, types, query);
        debug!("preparing query {name} with types {types:?}: {query}");
    }

    client.with_buf(|buf| {
diff --git a/tokio-postgres/src/simple_query.rs b/tokio-postgres/src/simple_query.rs
 }

 pub async fn simple_query(client: &InnerClient, query: &str) -> Result<SimpleQueryStream, Error> {
    debug!("executing simple query: {}", query);
    debug!("executing simple query: {query}");

    let buf = encode(client, query)?;
    let responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;
 }

 pub async fn batch_execute(client: &InnerClient, query: &str) -> Result<(), Error> {
    debug!("executing statement batch: {}", query);
    debug!("executing statement batch: {query}");

    let buf = encode(client, query)?;
    let mut responses = client.send(RequestMessages::Single(FrontendMessage::Raw(buf)))?;
diff --git a/tokio-postgres/src/transaction.rs b/tokio-postgres/src/transaction.rs

    async fn _savepoint(&mut self, name: Option<String>) -> Result<Transaction<'_>, Error> {
        let depth = self.savepoint.as_ref().map_or(0, |sp| sp.depth) + 1;
        let name = name.unwrap_or_else(|| format!("sp_{}", depth));
        let query = format!("SAVEPOINT {}", name);
        let name = name.unwrap_or_else(|| format!("sp_{depth}"));
        let query = format!("SAVEPOINT {name}");
        self.batch_execute(&query).await?;

        Ok(Transaction {
diff --git a/tokio-postgres/tests/test/binary_copy.rs b/tokio-postgres/tests/test/binary_copy.rs
    for i in 0..10_000i32 {
        writer
            .as_mut()
            .write(&[&i, &format!("the value for {}", i)])
            .write(&[&i, &format!("the value for {i}")])
            .await
            .unwrap();
    }
        .unwrap();
    for (i, row) in rows.iter().enumerate() {
        assert_eq!(row.get::<_, i32>(0), i as i32);
        assert_eq!(row.get::<_, &str>(1), format!("the value for {}", i));
        assert_eq!(row.get::<_, &str>(1), format!("the value for {i}"));
    }
 }


    for (i, row) in rows.iter().enumerate() {
        assert_eq!(row.get::<i32>(0), i as i32);
        assert_eq!(row.get::<&str>(1), format!("the value for {}", i));
        assert_eq!(row.get::<&str>(1), format!("the value for {i}"));
    }
 }

diff --git a/tokio-postgres/tests/test/main.rs b/tokio-postgres/tests/test/main.rs
    let a = Bytes::from_static(b"0\tname0\n");
    let mut b = BytesMut::new();
    for i in 1..5_000 {
        writeln!(b, "{0}\tname{0}", i).unwrap();
        writeln!(b, "{i}\tname{i}").unwrap();
    }
    let mut c = BytesMut::new();
    for i in 5_000..10_000 {
        writeln!(c, "{0}\tname{0}", i).unwrap();
        writeln!(c, "{i}\tname{i}").unwrap();
    }
    let mut stream = stream::iter(
        vec![a, b.freeze(), c.freeze()]
 async fn notices() {
    let long_name = "x".repeat(65);
    let (client, mut connection) =
        connect_raw(&format!("user=postgres application_name={}", long_name,))
        connect_raw(&format!("user=postgres application_name={long_name}",))
            .await
            .unwrap();

diff --git a/tokio-postgres/tests/test/parse.rs b/tokio-postgres/tests/test/parse.rs
 use tokio_postgres::config::{Config, SslNegotiation, TargetSessionAttrs};

 fn check(s: &str, config: &Config) {
    assert_eq!(s.parse::<Config>().expect(s), *config, "`{}`", s);
    assert_eq!(s.parse::<Config>().expect(s), *config, "`{s}`");
 }

 #[test]
Original file line number	Diff line number	Diff line change
Expand Up		@@ -72,7 +72,6 @@ fn make_code(codes: &LinkedHashMap<String, Vec<String>>, file: &mut BufWriter<Fi
		file,
		r#"
		Inner::E{code} => "{code}","#,
		code = code,
		)
		.unwrap();
		}
Expand All		@@ -97,8 +96,6 @@ fn make_consts(codes: &LinkedHashMap<String, Vec<String>>, file: &mut BufWriter<
		/// {code}
		pub const {name}: SqlState = SqlState(Inner::E{code});
		"#,
		name = name,
		code = code,
		)
		.unwrap();
		}
Expand All		@@ -121,8 +118,7 @@ enum Inner {{"#,
		write!(
		file,
		r#"
		E{},"#,
		code,
		E{code},"#,
		)
		.unwrap();
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -237,18 +237,18 @@ fn parse_types() -> BTreeMap<u32, Type> {
		let doc_name = array_re.replace(&name, "$1[]").to_ascii_uppercase();
		let mut doc = doc_name.clone();
		if let Some(descr) = raw_type.get("descr") {
		write!(doc, " - {}", descr).unwrap();
		write!(doc, " - {descr}").unwrap();
		}
		let doc = Escape::new(doc.as_bytes().iter().cloned()).collect();
		let doc = String::from_utf8(doc).unwrap();

		if let Some(array_type_oid) = raw_type.get("array_type_oid") {
		let array_type_oid = array_type_oid.parse::<u32>().unwrap();

		let name = format!("_{}", name);
		let variant = format!("{}Array", variant);
		let doc = format!("{}[]", doc_name);
		let ident = format!("{}_ARRAY", ident);
		let name = format!("_{name}");
		let variant = format!("{variant}Array");
		let doc = format!("{doc_name}[]");
		let ident = format!("{ident}_ARRAY");

		let type_ = Type {
		name,
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -21,7 +21,7 @@ where
		let result = conn.query_one(&stmt, &[]).unwrap().get(0);
		assert_eq!(val, &result);

		let stmt = conn.prepare(&format!("SELECT $1::{}", sql_type)).unwrap();
		let stmt = conn.prepare(&format!("SELECT $1::{sql_type}")).unwrap();
		let result = conn.query_one(&stmt, &[val]).unwrap().get(0);
		assert_eq!(val, &result);
		}
Expand All		@@ -45,7 +45,7 @@ pub fn test_type_asymmetric<T, F, S, C>(
		let result: F = conn.query_one(&stmt, &[]).unwrap().get(0);
		assert!(cmp(val, &result));

		let stmt = conn.prepare(&format!("SELECT $1::{}", sql_type)).unwrap();
		let stmt = conn.prepare(&format!("SELECT $1::{sql_type}")).unwrap();
		let result: F = conn.query_one(&stmt, &[val]).unwrap().get(0);
		assert!(cmp(val, &result));
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -65,7 +65,7 @@ impl Overrides {
		"invalid rename_all rule, expected one of: {}",
		RENAME_RULES
		.iter()
		.map(\|rule\| format!("\"{}\"", rule))
		.map(\|rule\| format!("\"{rule}\""))
		.collect::<Vec<_>>()
		.join(", ")
		),
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -196,7 +196,7 @@ fn composite_body(fields: &[Field]) -> TokenStream {
		postgres_types::IsNull::Yes => -1,
		postgres_types::IsNull::No =>{
		let len = buf.len() - base -4;
		if len >i32::max_value()asusize{
		if len >i32::MAXasusize{
		return std::result::Result::Err(
		std::convert::Into::into("value too large to transmit"));
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -14,7 +14,7 @@ pub fn md5_hash(username: &[u8], password: &[u8], salt: [u8; 4]) -> String {
		md5.update(password);
		md5.update(username);
		let output = md5.finalize_reset();
		md5.update(format!("{:x}", output));
		md5.update(format!("{output:x}"));
		md5.update(salt);
		format!("md5{:x}", md5.finalize())
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -262,7 +262,7 @@ impl ScramSha256 {

		let verifier = match parsed {
		ServerFinalMessage::Error(e) => {
		return Err(io::Error::other(format!("SCRAM error: {}", e)));
		return Err(io::Error::other(format!("SCRAM error: {e}")));
		}
		ServerFinalMessage::Verifier(verifier) => verifier,
		};
Expand DownExpand Up		@@ -302,10 +302,8 @@ impl<'a> Parser<'a> {
		match self.it.next() {
		Some((_, c)) if c == target => Ok(()),
		Some((i, c)) => {
		let m = format!(
		"unexpected character at byte {}: expected `{}` but got `{}",
		i, target, c
		);
		let m =
		format!("unexpected character at byte {i}: expected `{target}` but got `{c}");
		Err(io::Error::new(io::ErrorKind::InvalidInput, m))
		}
		None => Err(io::Error::new(
Expand DownExpand Up		@@ -371,7 +369,7 @@ impl<'a> Parser<'a> {
		match self.it.peek() {
		Some(&(i, _)) => Err(io::Error::new(
		io::ErrorKind::InvalidInput,
		format!("unexpected trailing data at byte {}", i),
		format!("unexpected trailing data at byte {i}"),
		)),
		None => Ok(()),
		}
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -235,7 +235,7 @@ impl Message {
		tag => {
		return Err(io::Error::new(
		io::ErrorKind::InvalidInput,
		format!("unknown authentication tag `{}`", tag),
		format!("unknown authentication tag `{tag}`"),
		));
		}
		},
Expand All		@@ -262,7 +262,7 @@ impl Message {
		tag => {
		return Err(io::Error::new(
		io::ErrorKind::InvalidInput,
		format!("unknown message tag `{}`", tag),
		format!("unknown message tag `{tag}`"),
		));
		}
		};
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -102,5 +102,5 @@ pub fn md5(password: &[u8], username: &str) -> String {
		letmut hash =Md5::new();
		hash.update(&salted_password);
		let digest = hash.finalize();
		format!("md5{:x}", digest)
		format!("md5{digest:x}")
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,7 +3,7 @@ use chrono_04::{
		DateTime, Duration, FixedOffset, Local, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Utc,
		};
		use postgres_protocol::types;
		use std::error::Error;
		use std::{convert::TryFrom,error::Error};

		use crate::{FromSql, IsNull, ToSql, Type};

Expand DownExpand Up		@@ -123,11 +123,9 @@ impl<'a> FromSql<'a> for NaiveDate {
		impl ToSql for NaiveDate {
		fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
		let jd = self.signed_duration_since(base().date()).num_days();
		if jd > i64::from(i32::max_value()) \|\| jd < i64::from(i32::min_value()) {
		return Err("value too large to transmit".into());
		}
		let jd = i32::try_from(jd).map_err(\|_\| "value too large to transmit")?;

		types::date_to_sql(jd as i32, w);
		types::date_to_sql(jd, w);
		Ok(IsNull::No)
		}

Expand Down