Address clippy warnings and add to gh actions

.github/workflows/clippy.yml

@@ -0,0 +1,86 @@
+name: Clippy
+
+on:
+  push:
+  pull_request:
+
+permissions:
+  contents: read
+  checks: write
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  clippy-rt:
+    name: clippy (sqlx-rt-oldapi) • ${{ matrix.rt }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rt:
+          - runtime-tokio-native-tls
+          - runtime-tokio-rustls
+          - runtime-async-std-native-tls
+          - runtime-async-std-rustls
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install system deps
+        run: sudo apt-get update -y && sudo apt-get install -y pkg-config libssl-dev
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-all-crates: true
+      - name: Run clippy (rt)
+        run: |
+          cargo clippy -p sqlx-rt-oldapi --no-default-features --features "${{ matrix.rt }}" --all-targets -- -D warnings
+
+  clippy-core:
+    name: clippy (sqlx-core-oldapi) • ${{ matrix.db }} • ${{ matrix.rt }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        db: [postgres, mysql, sqlite, mssql, any]
+        rt: [runtime-tokio-rustls]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install system deps
+        run: sudo apt-get update -y && sudo apt-get install -y pkg-config libssl-dev
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-all-crates: true
+      - name: Run clippy (core)
+        run: |
+          cargo clippy -p sqlx-core-oldapi --no-default-features --features "${{ matrix.rt }},${{ matrix.db }}" --all-targets -- -D warnings
+
+  clippy-root:
+    name: clippy (sqlx-oldapi) • ${{ matrix.combo }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        combo:
+          - "runtime-tokio-rustls,postgres,macros"
+          - "runtime-tokio-rustls,sqlite,macros"
+          - "runtime-tokio-rustls,mysql,macros"
+          - "runtime-async-std-rustls,postgres,macros"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install system deps
+        run: sudo apt-get update -y && sudo apt-get install -y pkg-config libssl-dev
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+        with:
+          cache-all-crates: true
+      - name: Run clippy (root)
+        run: |
+          cargo clippy -p sqlx-oldapi --no-default-features --features "${{ matrix.combo }}" --all-targets -- -D warnings
+

examples/postgres/axum-social-with-tests/tests/common.rs

@@ -1,5 +1,4 @@
 // This is imported by different tests that use different functions.
-#![allow(dead_code)]
 
 use axum::body::{Body, BoxBody, HttpBody};
 use axum::http::header::CONTENT_TYPE;

sqlx-core/src/any/connection/executor.rs

@@ -14,12 +14,13 @@ use futures_util::{StreamExt, TryStreamExt};
 impl<'c> Executor<'c> for &'c mut AnyConnection {
     type Database = Any;
 
-    fn fetch_many<'e, 'q: 'e, E: 'q>(
+    fn fetch_many<'e, 'q, E>(
         self,
         mut query: E,
     ) -> BoxStream<'e, Result<Either<AnyQueryResult, AnyRow>, Error>>
     where
         'c: 'e,
+        'q: 'e,
         E: Execute<'q, Self::Database>,
     {
         let arguments = query.take_arguments();
@@ -52,12 +53,10 @@ impl<'c> Executor<'c> for &'c mut AnyConnection {
         }
     }
 
-    fn fetch_optional<'e, 'q: 'e, E: 'q>(
-        self,
-        mut query: E,
-    ) -> BoxFuture<'e, Result<Option<AnyRow>, Error>>
+    fn fetch_optional<'e, 'q, E>(self, mut query: E) -> BoxFuture<'e, Result<Option<AnyRow>, Error>>
     where
         'c: 'e,
+        'q: 'e,
         E: Execute<'q, Self::Database>,
     {
         let arguments = query.take_arguments();
@@ -92,13 +91,14 @@ impl<'c> Executor<'c> for &'c mut AnyConnection {
         })
     }
 
-    fn prepare_with<'e, 'q: 'e>(
+    fn prepare_with<'e, 'q>(
         self,
         sql: &'q str,
         _parameters: &[AnyTypeInfo],
     ) -> BoxFuture<'e, Result<AnyStatement<'q>, Error>>
     where
         'c: 'e,
+        'q: 'e,
     {
         Box::pin(async move {
             Ok(match &mut self.0 {
@@ -118,12 +118,13 @@ impl<'c> Executor<'c> for &'c mut AnyConnection {
         })
     }
 
-    fn describe<'e, 'q: 'e>(
+    fn describe<'e, 'q>(
         self,
         sql: &'q str,
     ) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>>
     where
         'c: 'e,
+        'q: 'e,
     {
         Box::pin(async move {
             Ok(match &mut self.0 {

sqlx-core/src/any/statement.rs

@@ -33,7 +33,7 @@ impl<'q> Statement<'q> for AnyStatement<'q> {
 
     fn parameters(&self) -> Option<Either<&[AnyTypeInfo], usize>> {
         match &self.parameters {
-            Some(Either::Left(types)) => Some(Either::Left(&types)),
+            Some(Either::Left(types)) => Some(Either::Left(types)),
             Some(Either::Right(count)) => Some(Either::Right(*count)),
             None => None,
         }
@@ -55,6 +55,6 @@ where
             .column_names
             .get(*self)
             .ok_or_else(|| Error::ColumnNotFound((*self).into()))
-            .map(|v| *v)
+            .copied()
     }
 }

sqlx-core/src/common/mod.rs

@@ -1,12 +1,16 @@
 mod statement_cache;
 
 pub(crate) use statement_cache::StatementCache;
+#[cfg(feature = "sqlite")]
 use std::fmt::{Debug, Formatter};
+#[cfg(feature = "sqlite")]
 use std::ops::{Deref, DerefMut};
 
 /// A wrapper for `Fn`s that provides a debug impl that just says "Function"
+#[cfg(feature = "sqlite")]
 pub(crate) struct DebugFn<F: ?Sized>(pub F);
 
+#[cfg(feature = "sqlite")]
 impl<F: ?Sized> Deref for DebugFn<F> {
     type Target = F;
 
@@ -15,12 +19,14 @@ impl<F: ?Sized> Deref for DebugFn<F> {
     }
 }
 
+#[cfg(feature = "sqlite")]
 impl<F: ?Sized> DerefMut for DebugFn<F> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.0
     }
 }
 
+#[cfg(feature = "sqlite")]
 impl<F: ?Sized> Debug for DebugFn<F> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_tuple("Function").finish()

sqlx-core/src/connection.rs

@@ -116,10 +116,11 @@ pub trait Connection: Send {
     fn connect(url: &str) -> BoxFuture<'static, Result<Self, Error>>
     where
         Self: Sized,
+        Self::Options: FromStr<Err = Error>,
     {
         let options = url.parse();
 
-        Box::pin(async move { Ok(Self::connect_with(&options?).await?) })
+        Box::pin(async move { Self::connect_with(&options?).await })
     }
 
     /// Establish a new database connection with the provided options.
@@ -158,24 +159,31 @@ impl LogSettings {
     }
 }
 
-pub trait ConnectOptions: 'static + Send + Sync + FromStr<Err = Error> + Debug + Clone {
-    type Connection: Connection + ?Sized;
+pub trait ConnectOptions: Sized + Send + Sync + 'static {
+    type Connection: Connection;
 
-    /// Establish a new database connection with the options specified by `self`.
-    fn connect(&self) -> BoxFuture<'_, Result<Self::Connection, Error>>
+    fn from_url(url: &str) -> Result<Self, Error>
     where
-        Self::Connection: Sized;
+        Self: std::str::FromStr<Err = Error>,
+    {
+        Self::from_str(url)
+    }
 
-    /// Log executed statements with the specified `level`
-    fn log_statements(&mut self, level: LevelFilter) -> &mut Self;
+    fn connect(&self) -> BoxFuture<'_, Result<Self::Connection, Error>>;
 
-    /// Log executed statements with a duration above the specified `duration`
-    /// at the specified `level`.
-    fn log_slow_statements(&mut self, level: LevelFilter, duration: Duration) -> &mut Self;
+    fn connect_with(options: &Self) -> BoxFuture<'_, Result<Self::Connection, Error>> {
+        options.connect()
+    }
 
-    /// Entirely disables statement logging (both slow and regular).
-    fn disable_statement_logging(&mut self) -> &mut Self {
-        self.log_statements(LevelFilter::Off)
-            .log_slow_statements(LevelFilter::Off, Duration::default())
+    fn from_env() -> Result<Self, Error>
+    where
+        Self: std::str::FromStr<Err = Error>,
+    {
+        let url = std::env::var("DATABASE_URL").map_err(Error::config)?;
+        Self::from_str(&url)
     }
+
+    fn log_statements(&mut self, level: LevelFilter) -> &mut Self;
+
+    fn log_slow_statements(&mut self, level: LevelFilter, duration: Duration) -> &mut Self;
 }