Fix warnings and formatting

Author: michaelmior

src/db.rs

@@ -63,12 +63,12 @@ impl<'a> Iterator for MergedIterator<'a> {
                 }
             }
 
-            if let Some(doc) = result {
-                if !doc.is_null() {
-                    return Some((min_id, doc));
-                }
-                // If null (tombstone), loop again
+            if let Some(doc) = result
+                && !doc.is_null()
+            {
+                return Some((min_id, doc));
             }
+            // If null (tombstone), loop again
         }
     }
 }

src/jstable.rs

@@ -220,7 +220,7 @@ mod tests {
         let file = NamedTempFile::new().unwrap();
         jstable.write(file.path().to_str().unwrap()).unwrap();
 
-        let mut iterator = JSTableIterator::new(file.path().to_str().unwrap())?;
+        let iterator = JSTableIterator::new(file.path().to_str().unwrap())?;
         assert_eq!(iterator.timestamp, 12345);
 
         let mut count = 0;

src/main.rs

@@ -60,11 +60,7 @@ impl SimpleQueryHandler for ArgusHandler {
             Ok(s) => s,
             Err(e) => {
                 return Ok(vec![Response::Error(Box::new(
-                    PgWireError::ApiError(Box::new(std::io::Error::new(
-                        std::io::ErrorKind::Other,
-                        e,
-                    )))
-                    .into(),
+                    PgWireError::ApiError(Box::new(std::io::Error::other(e))).into(),
                 ))]);
             }
         };
@@ -86,7 +82,7 @@ impl SimpleQueryHandler for ArgusHandler {
                 )))])
             }
             Statement::Select(plan) => {
-                let iter = execute_plan(plan, &*db);
+                let iter = execute_plan(plan, &db);
 
                 let mut rows_data = Vec::new();
                 for (_, doc) in iter {
@@ -103,9 +99,7 @@ impl SimpleQueryHandler for ArgusHandler {
                 let obj = first.as_object().unwrap();
                 let fields: Vec<FieldInfo> = obj
                     .keys()
-                    .map(|k| {
-                        FieldInfo::new(k.clone().into(), None, None, Type::JSON, FieldFormat::Text)
-                    })
+                    .map(|k| FieldInfo::new(k.clone(), None, None, Type::JSON, FieldFormat::Text))
                     .collect();
                 let fields = Arc::new(fields);
 
@@ -173,4 +167,4 @@ async fn main() {
             let _ = process_socket(socket, None, processor).await;
         });
     }
-}
+}

src/parser.rs

@@ -11,13 +11,13 @@ struct ArgusDialect;
 
 impl Dialect for ArgusDialect {
     fn is_identifier_start(&self, ch: char) -> bool {
-        (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' || ch == '$'
+        ('a'..='z').contains(&ch) || ('A'..='Z').contains(&ch) || ch == '_' || ch == '$'
     }
 
     fn is_identifier_part(&self, ch: char) -> bool {
-        (ch >= 'a' && ch <= 'z')
-            || (ch >= 'A' && ch <= 'Z')
-            || (ch >= '0' && ch <= '9')
+        ('a'..='z').contains(&ch)
+            || ('A'..='Z').contains(&ch)
+            || ('0'..='9').contains(&ch)
             || ch == '_'
             || ch == '$'
     }
@@ -85,16 +85,13 @@ fn convert_query(query: &ast::Query) -> Result<LogicalPlan, String> {
     let mut offset_val = None;
 
     if let Some(limit_clause) = &query.limit_clause {
-        match limit_clause {
-            LimitClause::LimitOffset { limit, offset, .. } => {
-                if let Some(l) = limit {
-                    limit_val = Some(parse_limit_expr(l)?);
-                }
-                if let Some(o) = offset {
-                    offset_val = Some(parse_limit_expr(&o.value)?);
-                }
+        if let LimitClause::LimitOffset { limit, offset, .. } = limit_clause {
+            if let Some(l) = limit {
+                limit_val = Some(parse_limit_expr(l)?);
+            }
+            if let Some(o) = offset {
+                offset_val = Some(parse_limit_expr(&o.value)?);
             }
-            _ => {}
         }
     }
 
@@ -266,7 +263,8 @@ mod tests {
 
     #[test]
     fn test_parse_insert() {
-        let sql = r#"INSERT INTO users VALUES (`{"name": "Alice", "age": 30}`), (`{"name": "Bob"}`)"#;
+        let sql =
+            r#"INSERT INTO users VALUES (`{"name": "Alice", "age": 30}`), (`{"name": "Bob"}`)"#;
         let stmt = parse(sql).unwrap();
         match stmt {
             Statement::Insert {

src/query.rs

@@ -105,7 +105,7 @@ impl<'a> FilterOperator<'a> {
 impl<'a> Iterator for FilterOperator<'a> {
     type Item = (String, Value);
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some((id, doc)) = self.child.next() {
+        for (id, doc) in self.child.by_ref() {
             if evaluate_expression(&self.predicate, &doc) == Value::Bool(true) {
                 return Some((id, doc));
             }
@@ -203,9 +203,7 @@ impl<'a> Iterator for OffsetOperator<'a> {
     type Item = (String, Value);
     fn next(&mut self) -> Option<Self::Item> {
         while self.skipped < self.offset {
-            if self.child.next().is_none() {
-                return None;
-            }
+            self.child.next()?;
             self.skipped += 1;
         }
         self.child.next()