fix rust lints

PeerDB-io · Oct 5, 2023 · 0951fbd · 0951fbd
1 parent 3ec3b32
commit 0951fbd
Show file tree

Hide file tree

Showing 11 changed files with 86 additions and 86 deletions.
diff --git a/.github/workflows/rust-lint.yml b/.github/workflows/rust-lint.yml
@@ -26,5 +26,5 @@ jobs:
           components: clippy
 
       - name: clippy
-        run: cargo clippy --all-targets --all-features -- -D warnings
+        run: cargo clippy -- -D warnings
         working-directory: ./nexus
diff --git a/nexus/parser/src/lib.rs b/nexus/parser/src/lib.rs
@@ -23,7 +23,7 @@ pub struct NexusQueryParser {
 pub enum NexusStatement {
     PeerDDL {
         stmt: Statement,
-        ddl: PeerDDL,
+        ddl: Box<PeerDDL>,
     },
     PeerQuery {
         stmt: Statement,
@@ -55,7 +55,7 @@ impl NexusStatement {
         if let Some(ddl) = ddl {
             return Ok(NexusStatement::PeerDDL {
                 stmt: stmt.clone(),
-                ddl,
+                ddl: Box::new(ddl),
             });
         }
 
@@ -100,8 +100,7 @@ impl NexusQueryParser {
         let peers = tokio::task::block_in_place(move || {
             tokio::runtime::Handle::current().block_on(async move {
                 let catalog = self.catalog.lock().await;
-                let peers = catalog.get_peers().await;
-                peers
+                catalog.get_peers().await
             })
         });
 

diff --git a/nexus/peer-bigquery/src/ast.rs b/nexus/peer-bigquery/src/ast.rs
@@ -78,17 +78,19 @@ impl BigqueryAst {
 
         visit_function_arg_mut(query, |node| {
             if let FunctionArgExpr::Expr(arg_expr) = node {
-                if let Expr::Cast { expr: _, data_type } = arg_expr {
-                    if let DataType::Array(_) = data_type {
-                        let list = self
-                            .flatten_expr_to_in_list(&arg_expr)
-                            .expect("failed to flatten in function");
-                        let rewritten_array = Array {
-                            elem: list,
-                            named: true,
-                        };
-                        *node = FunctionArgExpr::Expr(Expr::Array(rewritten_array));
-                    }
+                if let Expr::Cast {
+                    expr: _,
+                    data_type: DataType::Array(_),
+                } = arg_expr
+                {
+                    let list = self
+                        .flatten_expr_to_in_list(arg_expr)
+                        .expect("failed to flatten in function");
+                    let rewritten_array = Array {
+                        elem: list,
+                        named: true,
+                    };
+                    *node = FunctionArgExpr::Expr(Expr::Array(rewritten_array));
                 }
             }
 

diff --git a/nexus/peer-bigquery/src/cursor.rs b/nexus/peer-bigquery/src/cursor.rs
@@ -9,7 +9,6 @@ use sqlparser::ast::Statement;
 use crate::BigQueryQueryExecutor;
 
 pub struct BigQueryCursor {
-    stmt: Statement,
     position: usize,
     stream: Mutex<SendableStream>,
     schema: SchemaRef,
@@ -42,7 +41,6 @@ impl BigQueryCursorManager {
 
                 // Create a new cursor
                 let cursor = BigQueryCursor {
-                    stmt: stmt.clone(),
                     position: 0,
                     stream: Mutex::new(stream),
                     schema,

diff --git a/nexus/peer-snowflake/src/auth.rs b/nexus/peer-snowflake/src/auth.rs
@@ -47,9 +47,8 @@ impl SnowflakeAuth {
         expiry_threshold: u64,
     ) -> anyhow::Result<Self> {
         let pkey = match password {
-            Some(pw) => {
-                DecodePrivateKey::from_pkcs8_encrypted_pem(&private_key, pw).context("Invalid private key or decryption failed")?
-            },
+            Some(pw) => DecodePrivateKey::from_pkcs8_encrypted_pem(&private_key, pw)
+                .context("Invalid private key or decryption failed")?,
             None => {
                 DecodePrivateKey::from_pkcs8_pem(&private_key).context("Invalid private key")?
             }
@@ -77,16 +76,15 @@ impl SnowflakeAuth {
     // Normalize the account identifer to a form that is embedded into the JWT.
     // Logic adapted from Snowflake's example Python code for key-pair authentication "sql-api-generate-jwt.py".
     fn normalize_account_identifier(raw_account: &str) -> String {
-        let split_index: usize;
-        if !raw_account.contains(".global") {
-            split_index = *raw_account
-                .find(".")
-                .get_or_insert(raw_account.chars().count());
+        let split_index = if !raw_account.contains(".global") {
+            *raw_account
+                .find('.')
+                .get_or_insert(raw_account.chars().count())
         } else {
-            split_index = *raw_account
-                .find("-")
-                .get_or_insert(raw_account.chars().count());
-        }
+            *raw_account
+                .find('-')
+                .get_or_insert(raw_account.chars().count())
+        };
         raw_account
             .to_uppercase()
             .chars()

diff --git a/nexus/peer-snowflake/src/cursor.rs b/nexus/peer-snowflake/src/cursor.rs
@@ -7,7 +7,6 @@ use sqlparser::ast::Statement;
 use tokio::sync::Mutex;
 
 pub struct SnowflakeCursor {
-    stmt: Statement,
     position: usize,
     stream: Mutex<SendableStream>,
     schema: SchemaRef,
@@ -39,7 +38,6 @@ impl SnowflakeCursorManager {
 
                 // Create a new cursor
                 let cursor = SnowflakeCursor {
-                    stmt: stmt.clone(),
                     position: 0,
                     stream: Mutex::new(stream),
                     schema,

diff --git a/nexus/peer-snowflake/src/lib.rs b/nexus/peer-snowflake/src/lib.rs
@@ -28,13 +28,13 @@ mod stream;
 
 const DEFAULT_REFRESH_THRESHOLD: u64 = 3000;
 const DEFAULT_EXPIRY_THRESHOLD: u64 = 3600;
-const SNOWFLAKE_URL_PREFIX: &'static str = "https://";
-const SNOWFLAKE_URL_SUFFIX: &'static str = ".snowflakecomputing.com/api/v2/statements";
+const SNOWFLAKE_URL_PREFIX: &str = "https://";
+const SNOWFLAKE_URL_SUFFIX: &str = ".snowflakecomputing.com/api/v2/statements";
 
-const DATE_OUTPUT_FORMAT: &'static str = "YYYY/MM/DD";
-const TIME_OUTPUT_FORMAT: &'static str = "HH:MI:SS.FF";
-const TIMESTAMP_OUTPUT_FORMAT: &'static str = "YYYY-MM-DDTHH24:MI:SS.FF";
-const TIMESTAMP_TZ_OUTPUT_FORMAT: &'static str = "YYYY-MM-DDTHH24:MI:SS.FFTZHTZM";
+const DATE_OUTPUT_FORMAT: &str = "YYYY/MM/DD";
+const TIME_OUTPUT_FORMAT: &str = "HH:MI:SS.FF";
+const TIMESTAMP_OUTPUT_FORMAT: &str = "YYYY-MM-DDTHH24:MI:SS.FF";
+const TIMESTAMP_TZ_OUTPUT_FORMAT: &str = "YYYY-MM-DDTHH24:MI:SS.FFTZHTZM";
 
 #[derive(Debug, Serialize)]
 struct SQLStatement<'a> {
@@ -59,7 +59,7 @@ pub(crate) struct ResultSetRowType {
     r#type: SnowflakeDataType,
 }
 
-#[allow(non_snake_case)]
+#[allow(non_snake_case, dead_code)]
 #[derive(Deserialize, Debug)]
 struct ResultSetPartitionInfo {
     rowCount: u64,
@@ -207,7 +207,7 @@ impl SnowflakeQueryExecutor {
         })
     }
 
-    pub async fn query(&self, query: &Box<Query>) -> PgWireResult<ResultSet> {
+    pub async fn query(&self, query: &Query) -> PgWireResult<ResultSet> {
         let mut query = query.clone();
 
         let ast = ast::SnowflakeAst::default();

diff --git a/nexus/peer-snowflake/src/stream.rs b/nexus/peer-snowflake/src/stream.rs
@@ -13,7 +13,6 @@ use pgwire::{
 };
 use secrecy::ExposeSecret;
 use serde::Deserialize;
-use serde_json;
 use std::{
     pin::Pin,
     task::{Context, Poll},
@@ -146,39 +145,47 @@ impl SnowflakeRecordStream {
                         // really hacky workaround for parsing the UTC timezone specifically.
                         SnowflakeDataType::TimestampLtz => {
                             match DateTime::parse_from_str(elem, TIMESTAMP_TZ_PARSE_FORMAT) {
-                                Ok(_) => TimestampWithTimeZone(Utc.from_utc_datetime(
-                                    &DateTime::parse_from_str(elem, TIMESTAMP_TZ_PARSE_FORMAT)?
+                                Ok(_) => TimestampWithTimeZone(
+                                    Utc.from_utc_datetime(
+                                        &DateTime::parse_from_str(elem, TIMESTAMP_TZ_PARSE_FORMAT)?
+                                            .naive_utc(),
+                                    ),
+                                ),
+                                Err(_) => TimestampWithTimeZone(
+                                    Utc.from_utc_datetime(
+                                        &DateTime::parse_from_str(
+                                            &elem.replace('Z', "+0000"),
+                                            TIMESTAMP_TZ_PARSE_FORMAT,
+                                        )?
                                         .naive_utc(),
-                                )),
-                                Err(_) => TimestampWithTimeZone(Utc.from_utc_datetime(
-                                    &DateTime::parse_from_str(
-                                        &elem.replace("Z", "+0000"),
-                                        TIMESTAMP_TZ_PARSE_FORMAT,
-                                    )?
-                                    .naive_utc(),
-                                )),
+                                    ),
+                                ),
                             }
                         }
                         SnowflakeDataType::TimestampNtz => PostgresTimestamp(
                             NaiveDateTime::parse_from_str(elem, TIMESTAMP_PARSE_FORMAT)?,
                         ),
                         SnowflakeDataType::TimestampTz => {
                             match DateTime::parse_from_str(elem, TIMESTAMP_TZ_PARSE_FORMAT) {
-                                Ok(_) => TimestampWithTimeZone(Utc.from_utc_datetime(
-                                    &DateTime::parse_from_str(elem, TIMESTAMP_TZ_PARSE_FORMAT)?
+                                Ok(_) => TimestampWithTimeZone(
+                                    Utc.from_utc_datetime(
+                                        &DateTime::parse_from_str(elem, TIMESTAMP_TZ_PARSE_FORMAT)?
+                                            .naive_utc(),
+                                    ),
+                                ),
+                                Err(_) => TimestampWithTimeZone(
+                                    Utc.from_utc_datetime(
+                                        &DateTime::parse_from_str(
+                                            &elem.replace('Z', "+0000"),
+                                            TIMESTAMP_TZ_PARSE_FORMAT,
+                                        )?
                                         .naive_utc(),
-                                )),
-                                Err(_) => TimestampWithTimeZone(Utc.from_utc_datetime(
-                                    &DateTime::parse_from_str(
-                                        &elem.replace("Z", "+0000"),
-                                        TIMESTAMP_TZ_PARSE_FORMAT,
-                                    )?
-                                    .naive_utc(),
-                                )),
+                                    ),
+                                ),
                             }
                         }
                         SnowflakeDataType::Variant => {
-                            let jsonb: serde_json::Value = serde_json::from_str(&elem)?;
+                            let jsonb: serde_json::Value = serde_json::from_str(elem)?;
                             Value::JsonB(jsonb)
                         }
                     },
@@ -188,7 +195,7 @@ impl SnowflakeRecordStream {
             row_values.push(row_value.unwrap_or(Value::Null));
         }
 
-        self.partition_index = self.partition_index + 1;
+        self.partition_index += 1;
 
         Ok(Record {
             values: row_values,
@@ -200,7 +207,7 @@ impl SnowflakeRecordStream {
         if (self.partition_number + 1) == self.result_set.resultSetMetaData.partitionInfo.len() {
             return Ok(false);
         }
-        self.partition_number = self.partition_number + 1;
+        self.partition_number += 1;
         self.partition_index = 0;
         let partition_number = self.partition_number;
         let secret = self.auth.get_jwt()?.expose_secret().clone();

diff --git a/nexus/server/src/cursor.rs b/nexus/server/src/cursor.rs
@@ -24,7 +24,7 @@ impl PeerCursors {
         self.cursors.remove(&name);
     }
 
-    pub fn get_peer(&self, name: &str) -> Option<&Box<Peer>> {
-        self.cursors.get(name)
+    pub fn get_peer(&self, name: &str) -> Option<&Peer> {
+        self.cursors.get(name).map(|peer| peer.as_ref())
     }
 }