chore: cleanup, fix all non-deprecation warnings

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

@@ -1,11 +0,0 @@
-use crate::any::options::AnyConnectOptions;
-use crate::any::AnyConnection;
-use crate::connection::Connection;
-use crate::error::Error;
-
-impl AnyConnection {
-    pub(crate) async fn establish(options: &AnyConnectOptions) -> Result<Self, Error> {
-        let driver = crate::any::driver::from_url(&options.database_url)?;
-        (driver.connect)(options).await
-    }
-}

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

@@ -1,7 +1,4 @@
-use crate::any::{
-    Any, AnyColumn, AnyConnection, AnyQueryResult, AnyRow, AnyStatement, AnyTypeInfo,
-};
-use crate::database::Database;
+use crate::any::{Any, AnyConnection, AnyQueryResult, AnyRow, AnyStatement, AnyTypeInfo};
 use crate::describe::Describe;
 use crate::error::Error;
 use crate::executor::{Execute, Executor};
@@ -57,23 +54,3 @@ impl<'c> Executor<'c> for &'c mut AnyConnection {
         self.backend.describe(sql)
     }
 }
-
-fn map_describe<DB: Database>(info: Describe<DB>) -> Describe<Any>
-where
-    AnyTypeInfo: From<DB::TypeInfo>,
-    AnyColumn: From<DB::Column>,
-{
-    let parameters = match info.parameters {
-        None => None,
-        Some(Either::Right(num)) => Some(Either::Right(num)),
-        Some(Either::Left(params)) => {
-            Some(Either::Left(params.into_iter().map(Into::into).collect()))
-        }
-    };
-
-    Describe {
-        parameters,
-        nullable: info.nullable,
-        columns: info.columns.into_iter().map(Into::into).collect(),
-    }
-}

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

@@ -10,7 +10,6 @@ pub use backend::AnyConnectionBackend;
 use crate::transaction::Transaction;
 
 mod backend;
-mod establish;
 mod executor;
 
 /// A connection to _any_ SQLx database.
@@ -33,7 +32,14 @@ impl AnyConnection {
         self.backend.name()
     }
 
-    pub(crate) fn connect<DB: Database>(
+    pub(crate) fn connect(options: &AnyConnectOptions) -> BoxFuture<'_, crate::Result<Self>> {
+        Box::pin(async {
+            let driver = crate::any::driver::from_url(&options.database_url)?;
+            (driver.connect)(options).await
+        })
+    }
+
+    pub(crate) fn connect_with_db<DB: Database>(
         options: &AnyConnectOptions,
     ) -> BoxFuture<'_, crate::Result<Self>>
     where

sqlx-core/src/any/driver.rs

@@ -1,21 +1,12 @@
 use crate::any::connection::AnyConnectionBackend;
-use crate::any::{
-    Any, AnyArguments, AnyConnectOptions, AnyConnection, AnyQueryResult, AnyRow, AnyStatement,
-    AnyTypeInfo,
-};
+use crate::any::{AnyConnectOptions, AnyConnection};
 use crate::common::DebugFn;
 use crate::connection::Connection;
 use crate::database::Database;
-use crate::describe::Describe;
-use crate::error::BoxDynError;
-use crate::transaction::Transaction;
 use crate::Error;
-use either::Either;
 use futures_core::future::BoxFuture;
-use futures_core::stream::BoxStream;
 use once_cell::sync::OnceCell;
 use std::fmt::{Debug, Formatter};
-use std::marker::PhantomData;
 use url::Url;
 
 static DRIVERS: OnceCell<&'static [AnyDriver]> = OnceCell::new();
@@ -52,7 +43,7 @@ impl AnyDriver {
         Self {
             name: DB::NAME,
             url_schemes: DB::URL_SCHEMES,
-            connect: DebugFn(AnyConnection::connect::<DB>),
+            connect: DebugFn(AnyConnection::connect_with_db::<DB>),
             migrate_database: None,
         }
     }

sqlx-core/src/any/migrate.rs

@@ -1,10 +1,8 @@
 use crate::any::driver;
-use crate::any::kind::AnyKind;
 use crate::any::{Any, AnyConnection};
 use crate::error::Error;
 use crate::migrate::{AppliedMigration, Migrate, MigrateDatabase, MigrateError, Migration};
 use futures_core::future::BoxFuture;
-use std::str::FromStr;
 use std::time::Duration;
 
 impl MigrateDatabase for Any {

sqlx-core/src/any/mod.rs

@@ -69,8 +69,7 @@ where
 {
     fn encode_by_ref(&self, buf: &mut AnyArgumentBuffer<'q>) -> crate::encode::IsNull {
         if let Some(value) = self {
-            value.encode_by_ref(buf);
-            crate::encode::IsNull::No
+            value.encode_by_ref(buf)
         } else {
             buf.0.push(AnyValueKind::Null);
             crate::encode::IsNull::Yes

sqlx-core/src/any/options.rs

@@ -45,7 +45,7 @@ impl ConnectOptions for AnyConnectOptions {
 
     #[inline]
     fn connect(&self) -> BoxFuture<'_, Result<AnyConnection, Error>> {
-        Box::pin(AnyConnection::establish(self))
+        AnyConnection::connect(self)
     }
 
     fn log_statements(mut self, level: LevelFilter) -> Self {

sqlx-core/src/any/value.rs

@@ -1,14 +1,8 @@
 use std::borrow::Cow;
-use std::marker::PhantomData;
-use std::num::TryFromIntError;
 
-use crate::any::error::mismatched_types;
 use crate::any::{Any, AnyTypeInfo, AnyTypeInfoKind};
 use crate::database::{Database, HasValueRef};
-use crate::decode::Decode;
-use crate::error::{BoxDynError, Error};
-use crate::io::Encode;
-use crate::type_info::TypeInfo;
+use crate::error::BoxDynError;
 use crate::types::Type;
 use crate::value::{Value, ValueRef};
 

sqlx-core/src/net/tls/mod.rs

@@ -77,7 +77,7 @@ where
     #[cfg(feature = "_tls-native-tls")]
     return Ok(with_socket.with_socket(tls_native_tls::handshake(socket, config).await?));
 
-    #[cfg(feature = "_tls-rustls")]
+    #[cfg(all(feature = "_tls-rustls", not(feature = "_tls-native-tls")))]
     return Ok(with_socket.with_socket(tls_rustls::handshake(socket, config).await?));
 
     #[cfg(not(any(feature = "_tls-native-tls", feature = "_tls-rustls")))]

sqlx-core/src/net/tls/tls_rustls.rs

@@ -1,5 +1,4 @@
 use futures_util::future;
-use rustls::{Certificate, PrivateKey};
 use std::io::{self, BufReader, Cursor, Read, Write};
 use std::sync::Arc;
 use std::task::{Context, Poll};
@@ -13,7 +12,7 @@ use rustls::{
 use crate::error::Error;
 use crate::io::ReadBuf;
 use crate::net::tls::util::StdSocket;
-use crate::net::tls::{CertificateInput, TlsConfig};
+use crate::net::tls::TlsConfig;
 use crate::net::Socket;
 
 pub struct RustlsSocket<S: Socket> {

sqlx-core/src/rt/mod.rs

@@ -23,7 +23,6 @@ pub enum JoinHandle<T> {
     _Phantom(PhantomData<fn() -> T>),
 }
 
-#[track_caller]
 pub async fn timeout<F: Future>(duration: Duration, f: F) -> Result<F::Output, TimeoutError> {
     #[cfg(feature = "_rt-tokio")]
     if rt_tokio::available() {
@@ -43,7 +42,6 @@ pub async fn timeout<F: Future>(duration: Duration, f: F) -> Result<F::Output, T
     missing_rt((duration, f))
 }
 
-#[track_caller]
 pub async fn sleep(duration: Duration) {
     #[cfg(feature = "_rt-tokio")]
     if rt_tokio::available() {
@@ -99,7 +97,6 @@ where
     missing_rt(f)
 }
 
-#[track_caller]
 pub async fn yield_now() {
     #[cfg(feature = "_rt-tokio")]
     if rt_tokio::available() {

sqlx-macros-core/src/database/mod.rs

@@ -62,7 +62,7 @@ impl<DB: DatabaseExt> CachingDescribeBlocking<DB> {
 
             let conn = match cache.entry(database_url.to_string()) {
                 hash_map::Entry::Occupied(hit) => hit.into_mut(),
-                hash_map::Entry::Vacant(mut miss) => {
+                hash_map::Entry::Vacant(miss) => {
                     miss.insert(DB::Connection::connect(&database_url).await?)
                 }
             };

sqlx-macros-core/src/derives/attributes.rs

@@ -1,5 +1,5 @@
 use proc_macro2::{Ident, Span, TokenStream};
-use quote::{quote, quote_spanned};
+use quote::quote;
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::token::Comma;

sqlx-macros-core/src/query/data.rs

@@ -10,7 +10,6 @@ use serde::{Serialize, Serializer};
 
 use sqlx_core::database::Database;
 use sqlx_core::describe::Describe;
-use sqlx_core::executor::Executor;
 
 use crate::database::DatabaseExt;
 
@@ -26,13 +25,6 @@ pub struct QueryData<DB: Database> {
 }
 
 impl<DB: Database> QueryData<DB> {
-    pub async fn from_db(
-        conn: impl Executor<'_, Database = DB>,
-        query: &str,
-    ) -> crate::Result<Self> {
-        Ok(Self::from_describe(query, conn.describe(query).await?))
-    }
-
     pub fn from_describe(query: &str, describe: Describe<DB>) -> Self {
         QueryData {
             db_name: SerializeDbName::default(),

sqlx-macros-core/src/query/mod.rs

@@ -8,7 +8,6 @@ use syn::Type;
 
 pub use input::QueryMacroInput;
 use quote::{format_ident, quote};
-use sqlx_core::connection::Connection;
 use sqlx_core::database::Database;
 use sqlx_core::{column::Column, describe::Describe, type_info::TypeInfo};
 

sqlx-mysql/src/any.rs

@@ -7,7 +7,6 @@ use either::Either;
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
 use futures_util::{StreamExt, TryFutureExt, TryStreamExt};
-use sqlx_core::any::driver::AnyDriver;
 use sqlx_core::any::{
     Any, AnyArguments, AnyColumn, AnyConnectOptions, AnyConnectionBackend, AnyQueryResult, AnyRow,
     AnyStatement, AnyTypeInfo, AnyTypeInfoKind,
@@ -17,7 +16,6 @@ use sqlx_core::database::Database;
 use sqlx_core::describe::Describe;
 use sqlx_core::executor::Executor;
 use sqlx_core::transaction::TransactionManager;
-use std::borrow::Cow;
 
 sqlx_core::declare_driver_with_optional_migrate!(DRIVER = MySql);
 
@@ -102,7 +100,7 @@ impl AnyConnectionBackend for MySqlConnection {
         let args = arguments.as_ref().map(AnyArguments::convert_to);
 
         Box::pin(async move {
-            let mut stream = self.run(query, args, persistent).await?;
+            let stream = self.run(query, args, persistent).await?;
             futures_util::pin_mut!(stream);
 
             if let Some(Either::Right(row)) = stream.try_next().await? {

sqlx-mysql/src/connection/auth.rs

@@ -3,7 +3,7 @@ use bytes::Bytes;
 use digest::{Digest, OutputSizeUser};
 use generic_array::GenericArray;
 use rand::thread_rng;
-use rsa::{pkcs8::DecodePublicKey, Oaep, PaddingScheme, PublicKey, RsaPublicKey};
+use rsa::{pkcs8::DecodePublicKey, Oaep, PublicKey, RsaPublicKey};
 use sha1::Sha1;
 use sha2::Sha256;
 

sqlx-postgres/src/any.rs

@@ -1,25 +1,18 @@
 use crate::{
-    Either, PgArguments, PgColumn, PgConnectOptions, PgConnection, PgQueryResult, PgRow,
-    PgTransactionManager, PgTypeInfo, Postgres,
+    Either, PgColumn, PgConnectOptions, PgConnection, PgQueryResult, PgRow, PgTransactionManager,
+    PgTypeInfo, Postgres,
 };
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
 use futures_util::{StreamExt, TryFutureExt, TryStreamExt};
-use std::borrow::Cow;
-use std::sync::Arc;
 
 pub use sqlx_core::any::*;
 
 use crate::type_info::PgType;
-use sqlx_core::any::driver::AnyDriver;
-use sqlx_core::column::Column;
 use sqlx_core::connection::Connection;
 use sqlx_core::database::Database;
 use sqlx_core::describe::Describe;
 use sqlx_core::executor::Executor;
-use sqlx_core::ext::ustr::UStr;
-use sqlx_core::row::Row;
-use sqlx_core::statement::Statement;
 use sqlx_core::transaction::TransactionManager;
 
 sqlx_core::declare_driver_with_optional_migrate!(DRIVER = Postgres);
@@ -105,7 +98,7 @@ impl AnyConnectionBackend for PgConnection {
         let args = arguments.as_ref().map(AnyArguments::convert_to);
 
         Box::pin(async move {
-            let mut stream = self.run(query, args, 1, persistent, None).await?;
+            let stream = self.run(query, args, 1, persistent, None).await?;
             futures_util::pin_mut!(stream);
 
             if let Some(Either::Right(row)) = stream.try_next().await? {

sqlx-postgres/src/connection/stream.rs

@@ -5,10 +5,7 @@ use std::str::FromStr;
 use futures_channel::mpsc::UnboundedSender;
 use futures_util::SinkExt;
 use log::Level;
-use sqlx_core::{
-    bytes::{Buf, Bytes},
-    logger,
-};
+use sqlx_core::bytes::{Buf, Bytes};
 
 use crate::connection::tls::MaybeUpgradeTls;
 use crate::error::Error;

sqlx-sqlite/src/any.rs

@@ -5,23 +5,17 @@ use crate::{
 use futures_core::future::BoxFuture;
 use futures_core::stream::BoxStream;
 use futures_util::{StreamExt, TryFutureExt, TryStreamExt};
-use std::borrow::Cow;
-use std::sync::Arc;
 
 use sqlx_core::any::{
     Any, AnyArguments, AnyColumn, AnyConnectOptions, AnyConnectionBackend, AnyQueryResult, AnyRow,
-    AnyStatement, AnyTypeInfo, AnyTypeInfoKind, AnyValue, AnyValueKind,
+    AnyStatement, AnyTypeInfo, AnyTypeInfoKind, AnyValueKind,
 };
 
 use crate::type_info::DataType;
-use sqlx_core::any::driver::AnyDriver;
-use sqlx_core::column::Column;
 use sqlx_core::connection::{ConnectOptions, Connection};
 use sqlx_core::database::Database;
 use sqlx_core::describe::Describe;
 use sqlx_core::executor::Executor;
-use sqlx_core::ext::ustr::UStr;
-use sqlx_core::row::Row;
 use sqlx_core::transaction::TransactionManager;
 
 sqlx_core::declare_driver_with_optional_migrate!(DRIVER = Sqlite);
@@ -109,7 +103,7 @@ impl AnyConnectionBackend for SqliteConnection {
         let args = arguments.map(map_arguments);
 
         Box::pin(async move {
-            let mut stream = self
+            let stream = self
                 .worker
                 .execute(query, args, self.row_channel_size, persistent)
                 .map_ok(flume::Receiver::into_stream)

sqlx-sqlite/src/connection/handle.rs

@@ -86,12 +86,6 @@ impl ConnectionHandle {
     }
 }
 
-impl ConnectionHandleRaw {
-    pub(crate) fn as_ptr(&self) -> *mut sqlite3 {
-        self.0.as_ptr()
-    }
-}
-
 impl Drop for ConnectionHandle {
     fn drop(&mut self) {
         unsafe {

sqlx-sqlite/src/connection/worker.rs

@@ -14,7 +14,6 @@ use sqlx_core::transaction::{
 };
 use sqlx_core::Either;
 
-use crate::connection::collation::create_collation;
 use crate::connection::describe::describe;
 use crate::connection::establish::EstablishParams;
 use crate::connection::ConnectionState;
@@ -30,7 +29,7 @@ use crate::{Sqlite, SqliteArguments, SqliteQueryResult, SqliteRow, SqliteStateme
 pub(crate) struct ConnectionWorker {
     command_tx: flume::Sender<Command>,
     /// The `sqlite3` pointer. NOTE: access is unsynchronized!
-    pub(crate) handle_raw: ConnectionHandleRaw,
+    pub(crate) _handle_raw: ConnectionHandleRaw,
     /// Mutex for locking access to the database.
     pub(crate) shared: Arc<WorkerSharedState>,
 }
@@ -64,10 +63,6 @@ enum Command {
     Rollback {
         tx: Option<rendezvous_oneshot::Sender<Result<(), Error>>>,
     },
-    CreateCollation {
-        create_collation:
-            Box<dyn FnOnce(&mut ConnectionState) -> Result<(), Error> + Send + Sync + 'static>,
-    },
     UnlockDb,
     ClearCache {
         tx: oneshot::Sender<()>,
@@ -109,7 +104,7 @@ impl ConnectionWorker {
                 if establish_tx
                     .send(Ok(Self {
                         command_tx,
-                        handle_raw: conn.handle.to_raw(),
+                        _handle_raw: conn.handle.to_raw(),
                         shared: Arc::clone(&shared),
                     }))
                     .is_err()
@@ -241,11 +236,6 @@ impl ConnectionWorker {
                                 }
                             }
                         }
-                        Command::CreateCollation { create_collation } => {
-                            if let Err(error) = (create_collation)(&mut conn) {
-                                tracing::warn!(%error, "error applying collation in background worker");
-                            }
-                        }
                         Command::ClearCache { tx } => {
                             conn.statements.clear();
                             update_cached_statements_size(&conn, &shared.cached_statements_size);
@@ -364,23 +354,6 @@ impl ConnectionWorker {
         rx.recv().await.map_err(|_| Error::WorkerCrashed)
     }
 
-    pub fn create_collation(
-        &mut self,
-        name: &str,
-        compare: impl Fn(&str, &str) -> std::cmp::Ordering + Send + Sync + 'static,
-    ) -> Result<(), Error> {
-        let name = name.to_string();
-
-        self.command_tx
-            .send(Command::CreateCollation {
-                create_collation: Box::new(move |conn| {
-                    create_collation(&mut conn.handle, &name, compare)
-                }),
-            })
-            .map_err(|_| Error::WorkerCrashed)?;
-        Ok(())
-    }
-
     pub(crate) async fn clear_cache(&mut self) -> Result<(), Error> {
         self.oneshot_cmd(|tx| Command::ClearCache { tx }).await
     }

sqlx-sqlite/src/migrate.rs

@@ -7,7 +7,6 @@ use crate::migrate::{AppliedMigration, Migration};
 use crate::migrate::{Migrate, MigrateDatabase};
 use crate::query::query;
 use crate::query_as::query_as;
-use crate::query_scalar::query_scalar;
 use crate::{Sqlite, SqliteConnectOptions, SqliteConnection, SqliteJournalMode};
 use futures_core::future::BoxFuture;
 use std::str::FromStr;