fix: resolve Rust 1.95 clippy lints (collapsible_match, sort_by_key, while_let, checked_div)

farhan-syah · farhan-syah · commit 96cbd80507c5 · 2026-04-17T02:59:08.000+08:00
diff --git a/nodedb-sql/src/planner/dml.rs b/nodedb-sql/src/planner/dml.rs
@@ -548,12 +548,10 @@ fn collect_pk_equalities(expr: &ast::Expr, pk: &str, keys: &mut Vec<SqlValue>) {
             expr: inner,
             list,
             negated: false,
-        } => {
-            if is_column(inner, pk) {
-                for item in list {
-                    if let Ok(v) = expr_to_sql_value(item) {
-                        keys.push(v);
-                    }
+        } if is_column(inner, pk) => {
+            for item in list {
+                if let Ok(v) = expr_to_sql_value(item) {
+                    keys.push(v);
                 }
             }
         }
diff --git a/nodedb-sql/src/planner/select.rs b/nodedb-sql/src/planner/select.rs
@@ -572,25 +572,24 @@ fn try_extract_sort_search(
                     },
                 }));
             }
-            SearchTrigger::TextSearch => {
-                if args.len() >= 2 {
-                    let query_text = extract_string_literal(&args[1])?;
-                    let limit = match plan {
-                        SqlPlan::Scan { limit, .. } => limit.unwrap_or(10),
-                        _ => 10,
-                    };
-                    return Ok(Some(SqlPlan::TextSearch {
-                        collection,
-                        query: query_text,
-                        top_k: limit,
-                        fuzzy: true,
-                        filters: match plan {
-                            SqlPlan::Scan { filters, .. } => filters.clone(),
-                            _ => Vec::new(),
-                        },
-                    }));
-                }
+            SearchTrigger::TextSearch if args.len() >= 2 => {
+                let query_text = extract_string_literal(&args[1])?;
+                let limit = match plan {
+                    SqlPlan::Scan { limit, .. } => limit.unwrap_or(10),
+                    _ => 10,
+                };
+                return Ok(Some(SqlPlan::TextSearch {
+                    collection,
+                    query: query_text,
+                    top_k: limit,
+                    fuzzy: true,
+                    filters: match plan {
+                        SqlPlan::Scan { filters, .. } => filters.clone(),
+                        _ => Vec::new(),
+                    },
+                }));
             }
+            SearchTrigger::TextSearch => {}
             SearchTrigger::HybridSearch => {
                 return plan_hybrid_from_sort(&args, &collection, plan, functions);
             }
diff --git a/nodedb/src/control/planner/procedural/executor/core/dispatch.rs b/nodedb/src/control/planner/procedural/executor/core/dispatch.rs
@@ -196,10 +196,7 @@ fn fold_literal_string_concat(sql: &str) -> String {
         };
 
         let mut folded = false;
-        loop {
-            let Some(op_end) = consume_string_concat_operator(bytes, cursor) else {
-                break;
-            };
+        while let Some(op_end) = consume_string_concat_operator(bytes, cursor) {
             let next_lit = skip_ascii_whitespace(bytes, op_end);
             let Some((next_cursor, next_literal)) = parse_single_quoted_literal(sql, next_lit)
             else {
diff --git a/nodedb/src/control/planner/sql_plan_convert/value/time_range.rs b/nodedb/src/control/planner/sql_plan_convert/value/time_range.rs
@@ -23,15 +23,15 @@ fn extract_time_bounds_from_filter(expr: &FilterExpr, min_ts: &mut i64, max_ts:
         FilterExpr::Comparison { field, op, value } if is_time_field(field) => {
             if let Some(ms) = sql_value_to_timestamp_ms(value) {
                 match op {
-                    nodedb_sql::types::CompareOp::Ge | nodedb_sql::types::CompareOp::Gt => {
-                        if ms > *min_ts {
-                            *min_ts = ms;
-                        }
+                    nodedb_sql::types::CompareOp::Ge | nodedb_sql::types::CompareOp::Gt
+                        if ms > *min_ts =>
+                    {
+                        *min_ts = ms;
                     }
-                    nodedb_sql::types::CompareOp::Le | nodedb_sql::types::CompareOp::Lt => {
-                        if ms < *max_ts {
-                            *max_ts = ms;
-                        }
+                    nodedb_sql::types::CompareOp::Le | nodedb_sql::types::CompareOp::Lt
+                        if ms < *max_ts =>
+                    {
+                        *max_ts = ms;
                     }
                     nodedb_sql::types::CompareOp::Eq => {
                         *min_ts = ms;
diff --git a/nodedb/src/control/security/catalog/checkpoints.rs b/nodedb/src/control/security/catalog/checkpoints.rs
@@ -110,7 +110,7 @@ impl SystemCatalog {
         }
 
         // Sort by created_at descending (most recent first).
-        records.sort_by(|a, b| b.created_at.cmp(&a.created_at));
+        records.sort_by_key(|r| std::cmp::Reverse(r.created_at));
 
         if records.len() > limit && limit > 0 {
             records.truncate(limit);
diff --git a/nodedb/src/control/security/explain.rs b/nodedb/src/control/security/explain.rs
@@ -166,13 +166,12 @@ pub fn lint_predicate(predicate: &super::predicate::RlsPredicate) -> Vec<String>
         super::predicate::RlsPredicate::AlwaysFalse => {
             warnings.push("contradiction: predicate is always false (blocks everything)".into());
         }
-        super::predicate::RlsPredicate::Compare { value, .. } => {
-            if !value.is_auth_ref() && matches!(value, super::predicate::PredicateValue::Literal(_))
-            {
-                warnings.push(
-                    "static predicate: no $auth reference — same result for all users".into(),
-                );
-            }
+        super::predicate::RlsPredicate::Compare { value, .. }
+            if !value.is_auth_ref()
+                && matches!(value, super::predicate::PredicateValue::Literal(_)) =>
+        {
+            warnings
+                .push("static predicate: no $auth reference — same result for all users".into());
         }
         super::predicate::RlsPredicate::And(children)
         | super::predicate::RlsPredicate::Or(children) => {
diff --git a/nodedb/src/control/server/native/session.rs b/nodedb/src/control/server/native/session.rs
@@ -418,17 +418,12 @@ fn chunk_large_response(
     };
     let sample_bytes = codec::encode_response(&sample_resp, format)?;
     let sample_count = total_rows.min(100);
-    let per_row_estimate = if sample_count > 0 {
-        sample_bytes.len() / sample_count
-    } else {
-        256 // fallback
-    };
+    let per_row_estimate = sample_bytes.len().checked_div(sample_count).unwrap_or(256);
 
-    let rows_per_chunk = if per_row_estimate > 0 {
-        (target_size / per_row_estimate).max(1)
-    } else {
-        1000
-    };
+    let rows_per_chunk = target_size
+        .checked_div(per_row_estimate)
+        .map(|v| v.max(1))
+        .unwrap_or(1000);
 
     let mut frames = Vec::new();
     let chunks: Vec<_> = rows.chunks(rows_per_chunk).collect();
diff --git a/nodedb/src/control/server/resp/handler.rs b/nodedb/src/control/server/resp/handler.rs
@@ -259,27 +259,23 @@ async fn handle_scan(cmd: &RespCommand, session: &RespSession, state: &SharedSta
                 i += 2;
             }
             // NodeDB extension: SCAN 0 FILTER <field> = <value>
-            Some(ref flag) if flag == "FILTER" => {
+            Some(ref flag) if flag == "FILTER" && i + 4 <= cmd.argc() => {
                 // Parse simple "field = value" predicate (needs 4 args: FILTER field = value).
-                if i + 4 <= cmd.argc() {
-                    let field = cmd.arg_str(i + 1).unwrap_or("");
-                    let _op = cmd.arg_str(i + 2).unwrap_or(""); // "=" expected
-                    let value = cmd.arg_str(i + 3).unwrap_or("");
-                    let scan_filter = serde_json::json!([{
-                        "field": field,
-                        "op": "eq",
-                        "value": value,
-                    }]);
-                    match nodedb_types::json_to_msgpack(&scan_filter) {
-                        Ok(bytes) => filter_bytes = bytes,
-                        Err(_) => {
-                            return RespValue::err("ERR filter serialization failed");
-                        }
+                let field = cmd.arg_str(i + 1).unwrap_or("");
+                let _op = cmd.arg_str(i + 2).unwrap_or(""); // "=" expected
+                let value = cmd.arg_str(i + 3).unwrap_or("");
+                let scan_filter = serde_json::json!([{
+                    "field": field,
+                    "op": "eq",
+                    "value": value,
+                }]);
+                match nodedb_types::json_to_msgpack(&scan_filter) {
+                    Ok(bytes) => filter_bytes = bytes,
+                    Err(_) => {
+                        return RespValue::err("ERR filter serialization failed");
                     }
-                    i += 4;
-                } else {
-                    i += 1;
                 }
+                i += 4;
             }
             _ => {
                 i += 1;
diff --git a/nodedb/src/control/server/sync/listener.rs b/nodedb/src/control/server/sync/listener.rs
@@ -316,9 +316,9 @@ async fn handle_sync_session(
                 }
             }
             Ok(Message::Ping(data)) => {
-                if ws.send(Message::Pong(data)).await.is_err() {
+                let Ok(_) = ws.send(Message::Pong(data)).await else {
                     break;
-                }
+                };
             }
             Ok(Message::Close(_)) => break,
             Err(e) => {
diff --git a/nodedb/src/data/executor/handlers/document/text_extract.rs b/nodedb/src/data/executor/handlers/document/text_extract.rs
@@ -14,10 +14,8 @@ pub fn extract_indexable_text(doc: &serde_json::Value) -> String {
 
 pub(super) fn collect_text(val: &serde_json::Value, parts: &mut Vec<String>) {
     match val {
-        serde_json::Value::String(s) => {
-            if !s.is_empty() {
-                parts.push(s.clone());
-            }
+        serde_json::Value::String(s) if !s.is_empty() => {
+            parts.push(s.clone());
         }
         serde_json::Value::Object(map) => {
             for v in map.values() {
diff --git a/nodedb/src/data/executor/handlers/facet.rs b/nodedb/src/data/executor/handlers/facet.rs
@@ -151,7 +151,7 @@ impl CoreLoop {
         }
 
         let mut result: Vec<(String, usize)> = counts.into_iter().collect();
-        result.sort_by(|a, b| b.1.cmp(&a.1)); // Count descending.
+        result.sort_by_key(|r| std::cmp::Reverse(r.1)); // Count descending.
         result
     }
 }
diff --git a/nodedb/src/engine/graph/algo/kcore.rs b/nodedb/src/engine/graph/algo/kcore.rs
@@ -91,7 +91,7 @@ pub fn run(csr: &CsrIndex) -> AlgoResultBatch {
 
     // Build result sorted by coreness descending.
     let mut scored: Vec<(usize, usize)> = coreness.into_iter().enumerate().collect();
-    scored.sort_by(|a, b| b.1.cmp(&a.1));
+    scored.sort_by_key(|&(_, k)| std::cmp::Reverse(k));
 
     let mut batch = AlgoResultBatch::new(GraphAlgorithm::KCore);
     for (node, k) in scored {
diff --git a/nodedb/src/engine/sparse/btree_scan.rs b/nodedb/src/engine/sparse/btree_scan.rs
@@ -190,7 +190,7 @@ impl SparseEngine {
         }
 
         let mut result: Vec<(String, usize)> = groups.into_iter().collect();
-        result.sort_by(|a, b| b.1.cmp(&a.1)); // Sort by count descending (most popular first).
+        result.sort_by_key(|r| std::cmp::Reverse(r.1)); // Sort by count descending (most popular first).
         debug!(
             collection,
             field,
diff --git a/nodedb/src/engine/timeseries/compound_filter.rs b/nodedb/src/engine/timeseries/compound_filter.rs
@@ -93,7 +93,7 @@ impl CompoundTagIndex {
             .iter()
             .map(|(k, &v)| (k.clone(), v))
             .collect();
-        combos.sort_by(|a, b| b.1.cmp(&a.1));
+        combos.sort_by_key(|c| std::cmp::Reverse(c.1));
         combos.truncate(n);
         combos
     }

Original file line number	Diff line number	Diff line change
`@@ -548,12 +548,10 @@ fn collect_pk_equalities(expr: &ast::Expr, pk: &str, keys: &mut Vec<SqlValue>) {`
`548`	`548`	`expr: inner,`
`549`	`549`	`list,`
`550`	`550`	`negated: false,`
`551`		`- } => {`
`552`		`- if is_column(inner, pk) {`
`553`		`- for item in list {`
`554`		`- if let Ok(v) = expr_to_sql_value(item) {`
`555`		`- keys.push(v);`
`556`		`- }`
	`551`	`+ } if is_column(inner, pk) => {`
	`552`	`+ for item in list {`
	`553`	`+ if let Ok(v) = expr_to_sql_value(item) {`
	`554`	`+ keys.push(v);`
`557`	`555`	`}`
`558`	`556`	`}`
`559`	`557`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ impl SystemCatalog {`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`// Sort by created_at descending (most recent first).`
`113`		`- records.sort_by(\|a, b\| b.created_at.cmp(&a.created_at));`
	`113`	`+ records.sort_by_key(\|r\| std::cmp::Reverse(r.created_at));`
`114`	`114`
`115`	`115`	`if records.len() > limit && limit > 0 {`
`116`	`116`	`records.truncate(limit);`
Original file line number	Diff line number	Diff line change
`@@ -316,9 +316,9 @@ async fn handle_sync_session(`
`316`	`316`	`}`
`317`	`317`	`}`
`318`	`318`	`Ok(Message::Ping(data)) => {`
`319`		`- if ws.send(Message::Pong(data)).await.is_err() {`
	`319`	`+ let Ok(_) = ws.send(Message::Pong(data)).await else {`
`320`	`320`	`break;`
`321`		`- }`
	`321`	`+ };`
`322`	`322`	`}`
`323`	`323`	`Ok(Message::Close(_)) => break,`
`324`	`324`	`Err(e) => {`