Checkpoint before follow-up message

Co-authored-by: contact <[email protected]>

Author: cursoragent

sqlx-core/src/connection.rs

@@ -119,7 +119,7 @@ pub trait Connection: Send {
     {
         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 +158,22 @@ 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>>
-    where
-        Self::Connection: Sized;
+    fn from_url(url: &str) -> Result<Self, Error>;
 
-    /// 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>>;
 
-    /// 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> {
+        let options = Self::from_url(&std::env::var("DATABASE_URL")?)?;
+        Box::pin(async move { Self::connect_with(&options?).await })
     }
+
+    fn create_pool(
+        &self,
+        options: crate::pool::PoolOptions<Self::Connection>,
+    ) -> Result<crate::pool::Pool<Self::Connection>, Error>;
 }

sqlx-core/src/logger.rs

@@ -99,16 +99,13 @@ impl<'q, O: Debug + Hash + Eq, R: Debug, P: Debug> QueryPlanLogger<'q, O, R, P>
     }
 
     pub(crate) fn log_enabled(&self) -> bool {
-        if let Some(_lvl) = self
-            .settings
-            .statements_level
-            .to_level()
-            .filter(|lvl| log::log_enabled!(target: "sqlx::explain", *lvl))
-        {
-            true
-        } else {
-            false
-        }
+        matches!(
+            self.settings
+                .statements_level
+                .to_level()
+                .filter(|lvl| log::log_enabled!(target: "sqlx::explain", *lvl)),
+            Some(_)
+        )
     }
 
     pub(crate) fn add_result(&mut self, result: R) {

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

@@ -72,7 +72,7 @@ impl MssqlConnection {
             server_name: &options.server_name,
             client_interface_name: &options.client_interface_name,
             language: &options.language,
-            database: &*options.database,
+            database: &options.database,
             client_id: [0; 6],
         };
 

sqlx-core/src/mssql/connection/prepare.rs

@@ -28,7 +28,7 @@ pub(crate) async fn prepare(
 
     for m in PARAMS_RE.captures_iter(sql) {
         if !params.is_empty() {
-            params.push_str(",");
+            params.push(',');
         }
 
         params.push_str(&m[0]);

sqlx-core/src/pool/inner.rs

@@ -406,14 +406,14 @@ impl<DB: Database> Drop for PoolInner<DB> {
 fn is_beyond_max_lifetime<DB: Database>(live: &Live<DB>, options: &PoolOptions<DB>) -> bool {
     options
         .max_lifetime
-        .map_or(false, |max| live.created_at.elapsed() > max)
+        .is_some_and(|max| live.created_at.elapsed() > max)
 }
 
 /// Returns `true` if the connection has exceeded `options.idle_timeout` if set, `false` otherwise.
 fn is_beyond_idle_timeout<DB: Database>(idle: &Idle<DB>, options: &PoolOptions<DB>) -> bool {
     options
         .idle_timeout
-        .map_or(false, |timeout| idle.idle_since.elapsed() > timeout)
+        .is_some_and(|timeout| idle.idle_since.elapsed() > timeout)
 }
 
 async fn check_idle_conn<DB: Database>(

sqlx-core/src/pool/mod.rs

@@ -353,7 +353,7 @@ impl<DB: Database> Pool<DB> {
 
     /// Retrieves a connection and immediately begins a new transaction.
     pub async fn begin(&self) -> Result<Transaction<'static, DB>, Error> {
-        Ok(Transaction::begin(MaybePoolConnection::PoolConnection(self.acquire().await?)).await?)
+        Transaction::begin(MaybePoolConnection::PoolConnection(self.acquire().await?)).await
     }
 
     /// Attempts to retrieve a connection and immediately begins a new transaction if successful.