fix: apply automatic clippy fixes and resolve type conversion issues

- Fix Cow<str> to Path conversions by using value.as_ref()
- Remove unnecessary mut from variable declaration
- Apply various automatic clippy fixes for redundant code

Author: cursoragent

sqlx-core/src/postgres/copy.rs

@@ -206,7 +206,7 @@ impl<C: DerefMut<Target = PgConnection>> PgCopyIn<C> {
             let stream = &mut buf_stream.stream;
 
             // ensures the buffer isn't left in an inconsistent state
-            let mut guard = BufGuard(&mut buf_stream.wbuf);
+            let guard = BufGuard(&mut buf_stream.wbuf);
 
             let buf: &mut Vec<u8> = guard.0;
             buf.push(b'd'); // CopyData format code

sqlx-core/src/postgres/message/data_row.rs

@@ -42,7 +42,7 @@ impl Decode<'_> for DataRow {
 
             if let Ok(length) = u32::try_from(length) {
                 values.push(Some(offset..(offset + length)));
-                offset += length as u32;
+                offset += length;
             } else {
                 values.push(None);
             }

sqlx-core/src/postgres/options/parse.rs

@@ -54,12 +54,12 @@ impl FromStr for PgConnectOptions {
                 }
 
                 "sslrootcert" | "ssl-root-cert" | "ssl-ca" => {
-                    options = options.ssl_root_cert(&value);
+                    options = options.ssl_root_cert(value.as_ref());
                 }
 
-                "sslcert" | "ssl-cert" => options = options.ssl_client_cert(&value),
+                "sslcert" | "ssl-cert" => options = options.ssl_client_cert(value.as_ref()),
 
-                "sslkey" | "ssl-key" => options = options.ssl_client_key(&value),
+                "sslkey" | "ssl-key" => options = options.ssl_client_key(value.as_ref()),
 
                 "statement-cache-capacity" => {
                     options =
@@ -68,39 +68,39 @@ impl FromStr for PgConnectOptions {
 
                 "host" => {
                     if value.starts_with("/") {
-                        options = options.socket(&value);
+                        options = options.socket(value.as_ref());
                     } else {
-                        options = options.host(&value);
+                        options = options.host(value.as_ref());
                     }
                 }
 
                 "hostaddr" => {
                     value.parse::<IpAddr>().map_err(Error::config)?;
-                    options = options.host(&value)
+                    options = options.host(value.as_ref())
                 }
 
                 "port" => options = options.port(value.parse().map_err(Error::config)?),
 
-                "dbname" => options = options.database(&value),
+                "dbname" => options = options.database(value.as_ref()),
 
-                "user" => options = options.username(&value),
+                "user" => options = options.username(value.as_ref()),
 
-                "password" => options = options.password(&value),
+                "password" => options = options.password(value.as_ref()),
 
-                "application_name" => options = options.application_name(&value),
+                "application_name" => options = options.application_name(value.as_ref()),
 
                 "options" => {
                     if let Some(options) = options.options.as_mut() {
                         options.push(' ');
-                        options.push_str(&value);
+                        options.push_str(value.as_ref());
                     } else {
                         options.options = Some(value.to_string());
                     }
                 }
 
                 k if k.starts_with("options[") => {
                     if let Some(key) = k.strip_prefix("options[").unwrap().strip_suffix(']') {
-                        options = options.options([(key, &value)]);
+                        options = options.options([(key, value.as_ref())]);
                     }
                 }
 

sqlx-core/src/postgres/options/ssl_mode.rs

@@ -5,6 +5,7 @@ use std::str::FromStr;
 ///
 /// It is used by the [`ssl_mode`](super::PgConnectOptions::ssl_mode) method.
 #[derive(Debug, Clone, Copy)]
+#[derive(Default)]
 pub enum PgSslMode {
     /// Only try a non-SSL connection.
     Disable,
@@ -13,6 +14,7 @@ pub enum PgSslMode {
     Allow,
 
     /// First try an SSL connection; if that fails, try a non-SSL connection.
+    #[default]
     Prefer,
 
     /// Only try an SSL connection. If a root CA file is present, verify the connection
@@ -28,11 +30,6 @@ pub enum PgSslMode {
     VerifyFull,
 }
 
-impl Default for PgSslMode {
-    fn default() -> Self {
-        PgSslMode::Prefer
-    }
-}
 
 impl FromStr for PgSslMode {
     type Err = Error;

sqlx-core/src/postgres/statement.rs

@@ -53,8 +53,7 @@ impl ColumnIndex<PgStatement<'_>> for &'_ str {
             .metadata
             .column_names
             .get(*self)
-            .ok_or_else(|| Error::ColumnNotFound((*self).into()))
-            .map(|v| *v)
+            .ok_or_else(|| Error::ColumnNotFound((*self).into())).copied()
     }
 }
 

sqlx-core/src/postgres/types/array.rs

@@ -94,7 +94,7 @@ where
     T: Encode<'q, Postgres> + Type<Postgres>,
 {
     fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull {
-        let type_info = if self.len() < 1 {
+        let type_info = if self.is_empty() {
             T::type_info()
         } else {
             self[0].produces().unwrap_or_else(T::type_info)

sqlx-core/src/postgres/types/interval.rs

@@ -182,7 +182,7 @@ impl TryFrom<std::time::Duration> for PgInterval {
     /// This returns an error if there is a loss of precision using nanoseconds or if there is a
     /// microsecond overflow.
     fn try_from(value: std::time::Duration) -> Result<Self, BoxDynError> {
-        if value.as_nanos() % 1000 != 0 {
+        if !value.as_nanos().is_multiple_of(1000) {
             return Err("PostgreSQL `INTERVAL` does not support nanoseconds precision".into());
         }
 

sqlx-core/src/postgres/types/lquery.rs

@@ -266,7 +266,7 @@ impl FromStr for PgLQueryVariant {
         let mut rev_iter = s.bytes().rev();
         let mut modifiers = PgLQueryVariantFlag::default();
 
-        while let Some(b) = rev_iter.next() {
+        for b in rev_iter {
             match b {
                 b'@' => modifiers.insert(PgLQueryVariantFlag::IN_CASE),
                 b'*' => modifiers.insert(PgLQueryVariantFlag::ANY_END),
@@ -307,8 +307,8 @@ impl Display for PgLQueryLevel {
             PgLQueryLevel::Star(Some(at_least), _) => write!(f, "*{{{},}}", at_least),
             PgLQueryLevel::Star(_, Some(at_most)) => write!(f, "*{{,{}}}", at_most),
             PgLQueryLevel::Star(_, _) => write!(f, "*"),
-            PgLQueryLevel::NonStar(variants) => write_variants(f, &variants, false),
-            PgLQueryLevel::NotNonStar(variants) => write_variants(f, &variants, true),
+            PgLQueryLevel::NonStar(variants) => write_variants(f, variants, false),
+            PgLQueryLevel::NotNonStar(variants) => write_variants(f, variants, true),
         }
     }
 }

sqlx-core/src/postgres/types/range.rs

@@ -518,7 +518,7 @@ fn range_compatible<E: Type<Postgres>>(ty: &PgTypeInfo) -> bool {
     // we require the declared type to be a _range_ with an
     // element type that is acceptable
     if let PgTypeKind::Range(element) = &ty.kind() {
-        return E::compatible(&element);
+        return E::compatible(element);
     }
 
     false

sqlx-core/src/query.rs

@@ -293,7 +293,7 @@ where
         let mut f = self.mapper;
         Map {
             inner: self.inner,
-            mapper: move |row| f(row).and_then(|o| g(o)),
+            mapper: move |row| f(row).and_then(&mut g),
         }
     }