Refactor: Improve Snowflake integration and examples

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

Author: cursoragent

examples/snowflake/basic/src/main.rs

@@ -1,7 +1,7 @@
 //! Basic Snowflake connection example
-//! 
+//!
 //! This example demonstrates the current state of Snowflake support in SQLx.
-//! 
+//!
 //! Note: This example shows the API structure but requires proper RSA key-pair
 //! authentication to work with a real Snowflake instance.
 
@@ -15,11 +15,11 @@ async fn main() -> Result<(), sqlx_oldapi::Error> {
 
     // Create connection options
     let options = SnowflakeConnectOptions::new()
-        .account("your-account")           // Replace with your Snowflake account
-        .username("your-username")         // Replace with your username
-        .warehouse("your-warehouse")       // Replace with your warehouse
-        .database("your-database")         // Replace with your database
-        .schema("your-schema");            // Replace with your schema
+        .account("your-account") // Replace with your Snowflake account
+        .username("your-username") // Replace with your username
+        .warehouse("your-warehouse") // Replace with your warehouse
+        .database("your-database") // Replace with your database
+        .schema("your-schema"); // Replace with your schema
 
     println!("📋 Configuration:");
     println!("   Account: {}", options.get_account());
@@ -36,7 +36,10 @@ async fn main() -> Result<(), sqlx_oldapi::Error> {
     // Execute a simple query
     println!("\n📊 Executing query...");
     let result = connection.execute("SELECT CURRENT_VERSION()").await?;
-    println!("✅ Query executed! Rows affected: {}", result.rows_affected());
+    println!(
+        "✅ Query executed! Rows affected: {}",
+        result.rows_affected()
+    );
 
     // Test connection ping
     println!("\n🏓 Testing connection ping...");
@@ -49,6 +52,6 @@ async fn main() -> Result<(), sqlx_oldapi::Error> {
     println!("✅ Connection closed!");
 
     println!("\n🎉 Example completed successfully!");
-    
+
     Ok(())
-}
+}

examples/snowflake_basic.rs

@@ -37,15 +37,18 @@ async fn main() -> Result<(), sqlx_oldapi::Error> {
                     println!("   Rows affected: {}", result.rows_affected());
                 }
                 Err(e) => {
-                    println!("⚠️  Query execution error (expected - auth not fully implemented): {}", e);
+                    println!(
+                        "⚠️  Query execution error (expected - auth not fully implemented): {}",
+                        e
+                    );
                 }
             }
 
             println!("\n🔒 Current Authentication Status:");
             println!("   ✅ JWT token generation (with dummy key)");
             println!("   ❌ RSA private key authentication (TODO)");
             println!("   ❌ OAuth authentication (TODO)");
-            
+
             println!("\n📡 API Integration Status:");
             println!("   ✅ HTTP client setup");
             println!("   ✅ Request formatting");
@@ -70,4 +73,4 @@ async fn main() -> Result<(), sqlx_oldapi::Error> {
     println!("   8. Create integration tests");
 
     Ok(())
-}
+}

sqlx-core/src/snowflake/arguments.rs

@@ -1,8 +1,7 @@
 use crate::arguments::Arguments;
 use crate::encode::{Encode, IsNull};
-use crate::snowflake::{Snowflake, SnowflakeTypeInfo};
+use crate::snowflake::Snowflake;
 use crate::types::Type;
-use std::borrow::Cow;
 
 /// Implementation of [`Arguments`] for Snowflake.
 #[derive(Debug, Default, Clone)]
@@ -12,7 +11,7 @@ pub struct SnowflakeArguments {
 }
 
 /// Implementation of [`ArgumentBuffer`] for Snowflake.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct SnowflakeArgumentBuffer {
     pub(crate) buffer: Vec<u8>,
 }
@@ -28,6 +27,10 @@ impl SnowflakeArguments {
         self.bindings.len()
     }
 
+    pub fn is_empty(&self) -> bool {
+        self.bindings.is_empty()
+    }
+
     pub(crate) fn get(&self, index: usize) -> Option<&String> {
         self.bindings.get(index)
     }
@@ -60,16 +63,8 @@ impl<'q> Arguments<'q> for SnowflakeArguments {
     }
 }
 
-impl Default for SnowflakeArgumentBuffer {
-    fn default() -> Self {
-        Self {
-            buffer: Vec::new(),
-        }
-    }
-}
-
 impl SnowflakeArgumentBuffer {
     pub fn new() -> Self {
         Self::default()
     }
-}
+}

sqlx-core/src/snowflake/column.rs

@@ -1,7 +1,5 @@
-use crate::column::{Column, ColumnIndex};
-use crate::error::Error;
+use crate::column::Column;
 use crate::snowflake::{Snowflake, SnowflakeTypeInfo};
-use std::borrow::Cow;
 
 /// Implementation of [`Column`] for Snowflake.
 #[derive(Debug, Clone)]

sqlx-core/src/snowflake/connection.rs

@@ -3,10 +3,7 @@ use crate::connection::Connection;
 use crate::describe::Describe;
 use crate::error::Error;
 use crate::executor::{Execute, Executor};
-use crate::snowflake::{
-    Snowflake, SnowflakeArguments, SnowflakeConnectOptions, SnowflakeQueryResult, SnowflakeRow,
-    SnowflakeStatement, SnowflakeTransactionManager, SnowflakeTypeInfo,
-};
+use crate::snowflake::{Snowflake, SnowflakeConnectOptions, SnowflakeQueryResult, SnowflakeStatement};
 use crate::transaction::Transaction;
 use either::Either;
 use futures_core::future::BoxFuture;
@@ -42,7 +39,11 @@ impl Debug for SnowflakeConnection {
 impl SnowflakeConnection {
     pub(crate) async fn establish(options: &SnowflakeConnectOptions) -> Result<Self, Error> {
         let client = reqwest::Client::builder()
-            .timeout(options.timeout.unwrap_or(std::time::Duration::from_secs(30)))
+            .timeout(
+                options
+                    .timeout
+                    .unwrap_or(std::time::Duration::from_secs(30)),
+            )
             .user_agent("SQLx-Snowflake/0.6.48")
             .build()
             .map_err(|e| Error::Configuration(e.into()))?;
@@ -70,7 +71,7 @@ impl SnowflakeConnection {
     async fn authenticate(&mut self) -> Result<(), Error> {
         // For now, implement username/password authentication
         // TODO: Implement JWT authentication with private key
-        
+
         if self.options.username.is_empty() {
             return Err(Error::Configuration(
                 "Username is required for Snowflake authentication".into(),
@@ -81,7 +82,7 @@ impl SnowflakeConnection {
         // In a real implementation, this would use RSA private keys
         let token = self.generate_jwt_token()?;
         self.auth_token = Some(token);
-        
+
         Ok(())
     }
 
@@ -123,7 +124,9 @@ impl SnowflakeConnection {
     pub(crate) async fn execute(&mut self, query: &str) -> Result<SnowflakeQueryResult, Error> {
         use serde_json::json;
 
-        let auth_token = self.auth_token.as_ref()
+        let auth_token = self
+            .auth_token
+            .as_ref()
             .ok_or_else(|| Error::Configuration("Not authenticated".into()))?;
 
         let request_body = json!({
@@ -135,29 +138,36 @@ impl SnowflakeConnection {
             "role": self.options.role
         });
 
-        let response = self.client
+        let response = self
+            .client
             .post(&self.base_url)
             .header("Authorization", format!("Bearer {}", auth_token))
             .header("Content-Type", "application/json")
             .header("Accept", "application/json")
             .json(&request_body)
             .send()
             .await
-            .map_err(|e| Error::Io(std::io::Error::new(std::io::ErrorKind::Other, e)))?;
+            .map_err(|e| Error::Io(std::io::Error::other(e)))?;
 
         if !response.status().is_success() {
             let status = response.status();
-            let error_text = response.text().await
+            let error_text = response
+                .text()
+                .await
                 .unwrap_or_else(|_| "Unknown error".to_string());
-            return Err(Error::Database(Box::new(crate::snowflake::SnowflakeDatabaseError::new(
-                status.as_u16().to_string(),
-                format!("HTTP {}: {}", status, error_text),
-                None,
-            ))));
+            return Err(Error::Database(Box::new(
+                crate::snowflake::SnowflakeDatabaseError::new(
+                    status.as_u16().to_string(),
+                    format!("HTTP {}: {}", status, error_text),
+                    None,
+                ),
+            )));
         }
 
-        let response_json: serde_json::Value = response.json().await
-            .map_err(|e| Error::Io(std::io::Error::new(std::io::ErrorKind::Other, e)))?;
+        let response_json: serde_json::Value = response
+            .json()
+            .await
+            .map_err(|e| Error::Io(std::io::Error::other(e)))?;
 
         // Parse the response to extract row count and other metadata
         let rows_affected = response_json
@@ -234,11 +244,14 @@ impl<'c> Executor<'c> for &'c mut SnowflakeConnection {
 
     fn fetch_many<'e, 'q: 'e, E>(
         self,
-        query: E,
+        _query: E,
     ) -> BoxStream<
         'e,
         Result<
-            Either<<Self::Database as crate::database::Database>::QueryResult, <Self::Database as crate::database::Database>::Row>,
+            Either<
+                <Self::Database as crate::database::Database>::QueryResult,
+                <Self::Database as crate::database::Database>::Row,
+            >,
             Error,
         >,
     >
@@ -253,7 +266,7 @@ impl<'c> Executor<'c> for &'c mut SnowflakeConnection {
 
     fn fetch_optional<'e, 'q: 'e, E>(
         self,
-        query: E,
+        _query: E,
     ) -> BoxFuture<'e, Result<Option<<Self::Database as crate::database::Database>::Row>, Error>>
     where
         'c: 'e,
@@ -270,7 +283,10 @@ impl<'c> Executor<'c> for &'c mut SnowflakeConnection {
         self,
         sql: &'q str,
         parameters: &'e [<Self::Database as crate::database::Database>::TypeInfo],
-    ) -> BoxFuture<'e, Result<<Self::Database as crate::database::HasStatement<'q>>::Statement, Error>>
+    ) -> BoxFuture<
+        'e,
+        Result<<Self::Database as crate::database::HasStatement<'q>>::Statement, Error>,
+    >
     where
         'c: 'e,
     {
@@ -288,7 +304,7 @@ impl<'c> Executor<'c> for &'c mut SnowflakeConnection {
 
     fn describe<'e, 'q: 'e>(
         self,
-        sql: &'q str,
+        _sql: &'q str,
     ) -> BoxFuture<'e, Result<Describe<Self::Database>, Error>>
     where
         'c: 'e,
@@ -303,4 +319,4 @@ impl<'c> Executor<'c> for &'c mut SnowflakeConnection {
             })
         })
     }
-}
+}

sqlx-core/src/snowflake/database.rs

@@ -46,4 +46,4 @@ impl<'q> HasStatement<'q> for Snowflake {
     type Statement = SnowflakeStatement<'q>;
 }
 
-impl HasStatementCache for Snowflake {}
+impl HasStatementCache for Snowflake {}

sqlx-core/src/snowflake/error.rs

@@ -55,4 +55,4 @@ impl DatabaseError for SnowflakeDatabaseError {
     fn into_error(self: Box<Self>) -> Box<dyn std::error::Error + Send + Sync + 'static> {
         self
     }
-}
+}

sqlx-core/src/snowflake/migrate.rs

@@ -1,2 +1,2 @@
 // Placeholder for migration support
-// TODO: Implement migration utilities for Snowflake
+// TODO: Implement migration utilities for Snowflake

sqlx-core/src/snowflake/mod.rs

@@ -34,7 +34,7 @@ pub use query_result::SnowflakeQueryResult;
 pub use row::SnowflakeRow;
 pub use statement::SnowflakeStatement;
 pub use transaction::SnowflakeTransactionManager;
-pub use type_info::{SnowflakeTypeInfo, SnowflakeType};
+pub use type_info::{SnowflakeType, SnowflakeTypeInfo};
 pub use value::{SnowflakeValue, SnowflakeValueRef};
 
 /// An alias for [`Pool`][crate::pool::Pool], specialized for Snowflake.
@@ -54,4 +54,4 @@ impl_acquire!(Snowflake, SnowflakeConnection);
 impl_column_index_for_row!(SnowflakeRow);
 impl_column_index_for_statement!(SnowflakeStatement);
 impl_into_maybe_pool!(Snowflake, SnowflakeConnection);
-impl_encode_for_option!(Snowflake);
+impl_encode_for_option!(Snowflake);

sqlx-core/src/snowflake/options.rs

@@ -1,6 +1,5 @@
 use crate::connection::ConnectOptions;
 use crate::error::Error;
-use std::borrow::Cow;
 use std::str::FromStr;
 use url::Url;
 
@@ -23,18 +22,13 @@ pub struct SnowflakeConnectOptions {
 /// SSL mode for Snowflake connections.
 /// 
 /// Snowflake always uses SSL, so this is mainly for future extensibility.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum SnowflakeSslMode {
     /// Always use SSL (default and only supported mode for Snowflake)
+    #[default]
     Require,
 }
 
-impl Default for SnowflakeSslMode {
-    fn default() -> Self {
-        SnowflakeSslMode::Require
-    }
-}
-
 impl SnowflakeConnectOptions {
     pub fn new() -> Self {
         Self {
@@ -197,9 +191,7 @@ impl ConnectOptions for SnowflakeConnectOptions {
     where
         Self::Connection: Sized,
     {
-        Box::pin(async move {
-            crate::snowflake::SnowflakeConnection::establish(self).await
-        })
+        Box::pin(async move { crate::snowflake::SnowflakeConnection::establish(self).await })
     }
 
     fn log_statements(&mut self, _level: log::LevelFilter) -> &mut Self {
@@ -215,4 +207,4 @@ impl ConnectOptions for SnowflakeConnectOptions {
         // TODO: implement slow statement logging
         self
     }
-}
+}