response: add non_exhaustive attribute to DbError

I extracted the part of speculative_execution::can_be_ignored as
DbError method. This way, we don't have to match against "_" (because
method is defined in the same module as the type - namely scylla_cql).

Author: muzarski

scylla-cql/src/frame/response/error.rs

@@ -151,6 +151,7 @@ impl Error {
 /// An error sent from the database in response to a query
 /// as described in the [specification](https://github.com/apache/cassandra/blob/5ed5e84613ef0e9664a774493db7d2604e3596e0/doc/native_protocol_v4.spec#L1029)\
 #[derive(Error, Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
 pub enum DbError {
     /// The submitted query has a syntax error
     #[error("The submitted query has a syntax error")]
@@ -386,6 +387,47 @@ impl DbError {
             } => protocol_features.rate_limit_error.unwrap(),
         }
     }
+
+    /// Decides whether the error can be ignored. If true, the driver can perform
+    /// a speculative retry to the next target.
+    pub fn can_speculative_retry(&self) -> bool {
+        // Do not remove this lint!
+        // It's there for a reason - we don't want new variants
+        // automatically fall under `_` pattern when they are introduced.
+        #[deny(clippy::wildcard_enum_match_arm)]
+        match self {
+            // Errors that will almost certainly appear on other nodes as well
+            DbError::SyntaxError
+            | DbError::Invalid
+            | DbError::AlreadyExists { .. }
+            | DbError::Unauthorized
+            | DbError::ProtocolError => false,
+
+            // Errors that should not appear there - thus, should not be ignored.
+            DbError::AuthenticationError | DbError::Other(_) => false,
+
+            // For now, let's assume that UDF failure is not transient - don't ignore it
+            // TODO: investigate
+            DbError::FunctionFailure { .. } => false,
+
+            // Not sure when these can appear - don't ignore them
+            // TODO: Investigate these errors
+            DbError::ConfigError | DbError::TruncateError => false,
+
+            // Errors that we can ignore and perform a retry on some other node
+            DbError::Unavailable { .. }
+            | DbError::Overloaded
+            | DbError::IsBootstrapping
+            | DbError::ReadTimeout { .. }
+            | DbError::WriteTimeout { .. }
+            | DbError::ReadFailure { .. }
+            | DbError::WriteFailure { .. }
+            // Preparation may succeed on some other node.
+            | DbError::Unprepared { .. }
+            | DbError::ServerError
+            | DbError::RateLimitReached { .. } => true,
+        }
+    }
 }
 
 /// Type of the operation rejected by rate limiting

scylla/src/policies/speculative_execution.rs

@@ -2,7 +2,6 @@ use futures::{
     future::FutureExt,
     stream::{FuturesUnordered, StreamExt},
 };
-use scylla_cql::frame::response::error::DbError;
 use std::{future::Future, sync::Arc, time::Duration};
 use tracing::{trace_span, warn, Instrument};
 
@@ -125,44 +124,7 @@ fn can_be_ignored<ResT>(result: &Result<ResT, RequestError>) -> bool {
                     | RequestAttemptError::UnableToAllocStreamId => true,
 
                     // Handle DbErrors
-                    RequestAttemptError::DbError(db_error, _) => {
-                        // Do not remove this lint!
-                        // It's there for a reason - we don't want new variants
-                        // automatically fall under `_` pattern when they are introduced.
-                        #[deny(clippy::wildcard_enum_match_arm)]
-                        match db_error {
-                            // Errors that will almost certainly appear on other nodes as well
-                            DbError::SyntaxError
-                            | DbError::Invalid
-                            | DbError::AlreadyExists { .. }
-                            | DbError::Unauthorized
-                            | DbError::ProtocolError => false,
-
-                            // Errors that should not appear there - thus, should not be ignored.
-                            DbError::AuthenticationError | DbError::Other(_) => false,
-
-                            // For now, let's assume that UDF failure is not transient - don't ignore it
-                            // TODO: investigate
-                            DbError::FunctionFailure { .. } => false,
-
-                            // Not sure when these can appear - don't ignore them
-                            // TODO: Investigate these errors
-                            DbError::ConfigError | DbError::TruncateError => false,
-
-                            // Errors that we can ignore and perform a retry on some other node
-                            DbError::Unavailable { .. }
-                            | DbError::Overloaded
-                            | DbError::IsBootstrapping
-                            | DbError::ReadTimeout { .. }
-                            | DbError::WriteTimeout { .. }
-                            | DbError::ReadFailure { .. }
-                            | DbError::WriteFailure { .. }
-                            // Preparation may succeed on some other node.
-                            | DbError::Unprepared { .. }
-                            | DbError::ServerError
-                            | DbError::RateLimitReached { .. } => true,
-                        }
-                    }
+                    RequestAttemptError::DbError(db_error, _) => db_error.can_speculative_retry(),
                 }
             }
         },