cargo clippy --fix --all-features -- -Wclippy::use_self

crates/duckdb/src/error.rs

@@ -135,7 +135,7 @@ impl From<FromSqlError> for Error {
             FromSqlError::OutOfRange(val) => Self::IntegralValueOutOfRange(UNKNOWN_COLUMN, val),
             #[cfg(feature = "uuid")]
             FromSqlError::InvalidUuidSize(_) => {
-                Error::FromSqlConversionFailure(UNKNOWN_COLUMN, Type::Blob, Box::new(err))
+                Self::FromSqlConversionFailure(UNKNOWN_COLUMN, Type::Blob, Box::new(err))
             }
             FromSqlError::Other(source) => Self::FromSqlConversionFailure(UNKNOWN_COLUMN, Type::Null, source),
             _ => Self::FromSqlConversionFailure(UNKNOWN_COLUMN, Type::Null, Box::new(err)),

crates/duckdb/src/polars_dataframe.rs

@@ -10,7 +10,7 @@ pub struct Polars<'stmt> {
 
 impl<'stmt> Polars<'stmt> {
     #[inline]
-    pub(crate) fn new(stmt: &'stmt Statement<'stmt>) -> Polars<'stmt> {
+    pub(crate) fn new(stmt: &'stmt Statement<'stmt>) -> Self {
         Polars { stmt: Some(stmt) }
     }
 

crates/duckdb/src/types/chrono.rs

@@ -96,7 +96,7 @@ impl FromSql for NaiveDateTime {
                         "%F"
                     }
                 };
-                NaiveDateTime::parse_from_str(s, format).map_err(|err| FromSqlError::Other(Box::new(err)))
+                Self::parse_from_str(s, format).map_err(|err| FromSqlError::Other(Box::new(err)))
             }
             _ => Err(FromSqlError::InvalidType),
         }
@@ -139,7 +139,7 @@ impl FromSql for Duration {
 
                 match nanos.try_into() {
                     Ok(nanos) => {
-                        if let Some(duration) = Duration::new(seconds, nanos) {
+                        if let Some(duration) = Self::new(seconds, nanos) {
                             Ok(duration)
                         } else {
                             Err(FromSqlError::Other("Invalid duration".into()))

crates/duckdb/src/types/from_sql.rs

@@ -31,7 +31,7 @@ impl PartialEq for FromSqlError {
             (Self::InvalidType, Self::InvalidType) => true,
             (Self::OutOfRange(n1), Self::OutOfRange(n2)) => n1 == n2,
             #[cfg(feature = "uuid")]
-            (FromSqlError::InvalidUuidSize(s1), FromSqlError::InvalidUuidSize(s2)) => s1 == s2,
+            (Self::InvalidUuidSize(s1), Self::InvalidUuidSize(s2)) => s1 == s2,
             (..) => false,
         }
     }
@@ -43,7 +43,7 @@ impl fmt::Display for FromSqlError {
             Self::InvalidType => write!(f, "Invalid type"),
             Self::OutOfRange(i) => write!(f, "Value {i} out of range"),
             #[cfg(feature = "uuid")]
-            FromSqlError::InvalidUuidSize(s) => {
+            Self::InvalidUuidSize(s) => {
                 write!(f, "Cannot read UUID value out of {s} byte blob")
             }
             Self::Other(ref err) => err.fmt(f),
@@ -240,7 +240,7 @@ impl FromSql for uuid::Uuid {
         match value {
             ValueRef::Text(..) => value
                 .as_str()
-                .and_then(|s| uuid::Uuid::parse_str(s).map_err(|_| FromSqlError::InvalidUuidSize(s.len()))),
+                .and_then(|s| Self::parse_str(s).map_err(|_| FromSqlError::InvalidUuidSize(s.len()))),
             ValueRef::Blob(..) => value
                 .as_blob()
                 .and_then(|bytes| {

crates/duckdb/src/types/url.rs

@@ -20,7 +20,7 @@ impl FromSql for Url {
         match value {
             ValueRef::Text(s) => {
                 let s = std::str::from_utf8(s).map_err(|e| FromSqlError::Other(Box::new(e)))?;
-                Url::parse(s).map_err(|e| FromSqlError::Other(Box::new(e)))
+                Self::parse(s).map_err(|e| FromSqlError::Other(Box::new(e)))
             }
             _ => Err(FromSqlError::InvalidType),
         }

crates/duckdb/src/types/value.rs

@@ -100,8 +100,8 @@ impl From<isize> for Value {
 #[cfg(feature = "uuid")]
 impl From<uuid::Uuid> for Value {
     #[inline]
-    fn from(id: uuid::Uuid) -> Value {
-        Value::Text(id.to_string())
+    fn from(id: uuid::Uuid) -> Self {
+        Self::Text(id.to_string())
     }
 }
 

crates/duckdb/src/vscalar/arrow.rs

@@ -23,22 +23,22 @@ pub enum ArrowScalarParams {
 impl AsRef<[DataType]> for ArrowScalarParams {
     fn as_ref(&self) -> &[DataType] {
         match self {
-            ArrowScalarParams::Exact(params) => params.as_ref(),
-            ArrowScalarParams::Variadic(param) => std::slice::from_ref(param),
+            Self::Exact(params) => params.as_ref(),
+            Self::Variadic(param) => std::slice::from_ref(param),
         }
     }
 }
 
 impl From<ArrowScalarParams> for ScalarParams {
     fn from(params: ArrowScalarParams) -> Self {
         match params {
-            ArrowScalarParams::Exact(params) => ScalarParams::Exact(
+            ArrowScalarParams::Exact(params) => Self::Exact(
                 params
                     .into_iter()
                     .map(|v| LogicalTypeId::try_from(&v).expect("type should be converted").into())
                     .collect(),
             ),
-            ArrowScalarParams::Variadic(param) => ScalarParams::Variadic(
+            ArrowScalarParams::Variadic(param) => Self::Variadic(
                 LogicalTypeId::try_from(&param)
                     .expect("type should be converted")
                     .into(),
@@ -58,15 +58,15 @@ pub struct ArrowFunctionSignature {
 impl ArrowFunctionSignature {
     /// Create an exact function signature
     pub fn exact(params: Vec<DataType>, return_type: DataType) -> Self {
-        ArrowFunctionSignature {
+        Self {
             parameters: Some(ArrowScalarParams::Exact(params)),
             return_type,
         }
     }
 
     /// Create a variadic function signature
     pub fn variadic(param: DataType, return_type: DataType) -> Self {
-        ArrowFunctionSignature {
+        Self {
             parameters: Some(ArrowScalarParams::Variadic(param)),
             return_type,
         }
@@ -152,7 +152,7 @@ mod test {
 
     impl Default for MockState {
         fn default() -> Self {
-            MockState {
+            Self {
                 info: "some meta".to_string(),
             }
         }

crates/duckdb/src/vscalar/function.rs

@@ -123,7 +123,7 @@ impl ScalarFunction {
         duckdb_scalar_function_set_extra_info(self.ptr, extra_info, destroy);
     }
 
-    pub fn set_extra_info<T: Default>(&self) -> &ScalarFunction {
+    pub fn set_extra_info<T: Default>(&self) -> &Self {
         unsafe {
             let t = Box::new(T::default());
             let c_void = Box::into_raw(t) as *mut c_void;

crates/duckdb/src/vscalar/mod.rs

@@ -63,15 +63,15 @@ pub struct ScalarFunctionSignature {
 impl ScalarFunctionSignature {
     /// Create an exact function signature
     pub fn exact(params: Vec<LogicalTypeHandle>, return_type: LogicalTypeHandle) -> Self {
-        ScalarFunctionSignature {
+        Self {
             parameters: Some(ScalarParams::Exact(params)),
             return_type,
         }
     }
 
     /// Create a variadic function signature
     pub fn variadic(param: LogicalTypeHandle, return_type: LogicalTypeHandle) -> Self {
-        ScalarFunctionSignature {
+        Self {
             parameters: Some(ScalarParams::Variadic(param)),
             return_type,
         }
@@ -201,7 +201,7 @@ mod test {
 
     impl Default for TestState {
         fn default() -> Self {
-            TestState { inner: 42 }
+            Self { inner: 42 }
         }
     }
 

crates/duckdb/src/vtab/function.rs

@@ -297,7 +297,7 @@ impl TableFunction {
     ///
     /// # Arguments
     ///  * `name`: The name of the table function
-    pub fn set_name(&self, name: &str) -> &TableFunction {
+    pub fn set_name(&self, name: &str) -> &Self {
         unsafe {
             let string = CString::from_vec_unchecked(name.as_bytes().into());
             duckdb_table_function_set_name(self.ptr, string.as_ptr());