aw-query: Fix clippy issues

johan-bjareholt · johan-bjareholt · commit 6f69b8ba21b8 · 2020-03-26T11:24:57.000+01:00
Removes quite a few clones as well, some queries might become significantly
faster now
diff --git a/aw-query/src/datatype.rs b/aw-query/src/datatype.rs
@@ -27,8 +27,9 @@ pub enum DataType {
     Function(String, functions::QueryFn),
 }
 
+#[allow(clippy::trivially_copy_pass_by_ref)]
 fn serialize_function<S>(
-    _element: &String,
+    _element: &str,
     _fun: &functions::QueryFn,
     _serializer: S,
 ) -> Result<S::Ok, S::Error>
@@ -132,7 +133,7 @@ impl TryFrom<&DataType> for Vec<String> {
             let s: String = (&string).try_into()?;
             strings.push(s);
         }
-        return Ok(strings);
+        Ok(strings)
     }
 }
 
@@ -152,7 +153,7 @@ impl TryFrom<&DataType> for Vec<Event> {
                 }
             }
         }
-        return Ok(events);
+        Ok(events)
     }
 }
 
@@ -184,7 +185,7 @@ impl TryFrom<&DataType> for Vec<(String, Rule)> {
                 }
             }
         }
-        return Ok(lists);
+        Ok(lists)
     }
 }
 
@@ -216,7 +217,7 @@ impl TryFrom<&DataType> for Vec<(Vec<String>, Rule)> {
                 }
             }
         }
-        return Ok(lists);
+        Ok(lists)
     }
 }
 
@@ -255,7 +256,7 @@ impl TryFrom<&DataType> for Value {
                 for value in tagged_values.drain(..) {
                     values.push((&value).try_into()?);
                 }
-                return Ok(Value::Array(values));
+                Ok(Value::Array(values))
             }
             ref invalid_type => Err(QueryError::InvalidFunctionParameters(format!(
                 "Query2 support for parsing values is limited, does not support parsing {:?}",
@@ -273,7 +274,7 @@ impl TryFrom<&DataType> for Vec<Value> {
         for value in tagged_values.drain(..) {
             values.push((&value).try_into()?);
         }
-        return Ok(values);
+        Ok(values)
     }
 }
 
@@ -307,7 +308,7 @@ impl TryFrom<&DataType> for Rule {
             }
         };
         if rtype == "none" {
-            return Ok(Self::None);
+            Ok(Self::None)
         } else if rtype == "regex" {
             let regex_val = match obj.get("regex") {
                 Some(regex_val) => regex_val,
@@ -346,12 +347,12 @@ impl TryFrom<&DataType> for Rule {
                     )))
                 }
             };
-            return Ok(Self::Regex(regex_rule));
+            Ok(Self::Regex(regex_rule))
         } else {
-            return Err(QueryError::InvalidFunctionParameters(format!(
+            Err(QueryError::InvalidFunctionParameters(format!(
                 "Unknown rule type '{}'",
                 rtype
-            )));
+            )))
         }
     }
 }
diff --git a/aw-query/src/functions.rs b/aw-query/src/functions.rs
@@ -108,7 +108,6 @@ mod qfunctions {
     use super::validate;
     use crate::DataType;
     use crate::QueryError;
-    use aw_transform;
 
     pub fn print(
         args: Vec<DataType>,
@@ -118,7 +117,7 @@ mod qfunctions {
         for arg in args {
             info!("{:?}", arg);
         }
-        return Ok(DataType::None());
+        Ok(DataType::None())
     }
 
     pub fn query_bucket(
@@ -133,8 +132,8 @@ mod qfunctions {
 
         let events = match ds.get_events(
             bucket_id.as_str(),
-            Some(interval.start().clone()),
-            Some(interval.end().clone()),
+            Some(*interval.start()),
+            Some(*interval.end()),
             None,
         ) {
             Ok(events) => events,
@@ -149,7 +148,7 @@ mod qfunctions {
         for event in events {
             ret.push(DataType::Event(event));
         }
-        return Ok(DataType::List(ret));
+        Ok(DataType::List(ret))
     }
 
     pub fn query_bucket_names(
@@ -171,7 +170,7 @@ mod qfunctions {
         for bucketname in buckets.keys() {
             bucketnames.push(DataType::String(bucketname.to_string()));
         }
-        return Ok(DataType::List(bucketnames));
+        Ok(DataType::List(bucketnames))
     }
 
     pub fn find_bucket(
@@ -199,7 +198,7 @@ mod qfunctions {
                 )))
             }
         };
-        return Ok(DataType::String(bucketname));
+        Ok(DataType::String(bucketname))
     }
 
     pub fn contains(
@@ -210,9 +209,7 @@ mod qfunctions {
         // typecheck
         validate::args_length(&args, 2)?;
         match args[0] {
-            DataType::List(ref list) => {
-                return Ok(DataType::Bool(list.contains(&args[1])));
-            }
+            DataType::List(ref list) => Ok(DataType::Bool(list.contains(&args[1]))),
             DataType::Dict(ref dict) => {
                 let s = match &args[1] {
                     DataType::String(s) => s.to_string(),
@@ -223,14 +220,12 @@ mod qfunctions {
                         )))
                     }
                 };
-                return Ok(DataType::Bool(dict.contains_key(&s)));
-            }
-            _ => {
-                return Err(QueryError::InvalidFunctionParameters(format!(
-                    "function contains got first argument {:?}, expected type List or Dict",
-                    args[0]
-                )))
+                Ok(DataType::Bool(dict.contains_key(&s)))
             }
+            _ => Err(QueryError::InvalidFunctionParameters(format!(
+                "function contains got first argument {:?}, expected type List or Dict",
+                args[0]
+            ))),
         }
     }
 
@@ -249,7 +244,7 @@ mod qfunctions {
         for event in flooded_events.drain(..) {
             tagged_flooded_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(tagged_flooded_events));
+        Ok(DataType::List(tagged_flooded_events))
     }
 
     pub fn categorize(
@@ -268,7 +263,7 @@ mod qfunctions {
         for event in flooded_events.drain(..) {
             tagged_flooded_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(tagged_flooded_events));
+        Ok(DataType::List(tagged_flooded_events))
     }
 
     pub fn tag(
@@ -287,7 +282,7 @@ mod qfunctions {
         for event in flooded_events.drain(..) {
             tagged_flooded_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(tagged_flooded_events));
+        Ok(DataType::List(tagged_flooded_events))
     }
 
     pub fn sort_by_duration(
@@ -306,7 +301,7 @@ mod qfunctions {
         for event in sorted_events.drain(..) {
             tagged_sorted_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(tagged_sorted_events));
+        Ok(DataType::List(tagged_sorted_events))
     }
 
     pub fn limit_events(
@@ -326,7 +321,7 @@ mod qfunctions {
         for event in events.drain(0..limit) {
             limited_tagged_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(limited_tagged_events));
+        Ok(DataType::List(limited_tagged_events))
     }
 
     pub fn sort_by_timestamp(
@@ -345,7 +340,7 @@ mod qfunctions {
         for event in sorted_events.drain(..) {
             tagged_sorted_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(tagged_sorted_events));
+        Ok(DataType::List(tagged_sorted_events))
     }
 
     pub fn sum_durations(
@@ -362,9 +357,9 @@ mod qfunctions {
         for event in events.drain(..) {
             sum_durations = sum_durations + event.duration;
         }
-        return Ok(DataType::Number(
+        Ok(DataType::Number(
             (sum_durations.num_milliseconds() as f64) / 1000.0,
-        ));
+        ))
     }
 
     pub fn merge_events_by_keys(
@@ -382,7 +377,7 @@ mod qfunctions {
         for event in merged_events.drain(..) {
             merged_tagged_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(merged_tagged_events));
+        Ok(DataType::List(merged_tagged_events))
     }
 
     pub fn chunk_events_by_key(
@@ -400,7 +395,7 @@ mod qfunctions {
         for event in merged_events.drain(..) {
             merged_tagged_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(merged_tagged_events));
+        Ok(DataType::List(merged_tagged_events))
     }
 
     pub fn filter_keyvals(
@@ -419,7 +414,7 @@ mod qfunctions {
         for event in filtered_events.drain(..) {
             filtered_tagged_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(filtered_tagged_events));
+        Ok(DataType::List(filtered_tagged_events))
     }
 
     pub fn filter_period_intersect(
@@ -437,7 +432,7 @@ mod qfunctions {
         for event in filtered_events.drain(..) {
             filtered_tagged_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(filtered_tagged_events));
+        Ok(DataType::List(filtered_tagged_events))
     }
 
     pub fn split_url_events(
@@ -454,7 +449,7 @@ mod qfunctions {
             aw_transform::split_url_event(&mut event);
             tagged_split_url_events.push(DataType::Event(event));
         }
-        return Ok(DataType::List(tagged_split_url_events));
+        Ok(DataType::List(tagged_split_url_events))
     }
 
     pub fn concat(
@@ -469,7 +464,7 @@ mod qfunctions {
                 event_list.push(DataType::Event(event));
             }
         }
-        return Ok(DataType::List(event_list));
+        Ok(DataType::List(event_list))
     }
 }
 
@@ -478,15 +473,15 @@ mod validate {
     use aw_models::TimeInterval;
     use std::collections::HashMap;
 
-    pub fn args_length(args: &Vec<DataType>, len: usize) -> Result<(), QueryError> {
+    pub fn args_length(args: &[DataType], len: usize) -> Result<(), QueryError> {
         if args.len() != len {
             return Err(QueryError::InvalidFunctionParameters(format!(
                 "Expected {} parameters in function, got {}",
                 len,
                 args.len()
             )));
         }
-        return Ok(());
+        Ok(())
     }
 
     pub fn get_timeinterval(env: &HashMap<&str, DataType>) -> Result<TimeInterval, QueryError> {
diff --git a/aw-query/src/interpret.rs b/aw-query/src/interpret.rs
@@ -13,7 +13,7 @@ fn init_env<'a>(ti: &TimeInterval) -> HashMap<&'a str, DataType> {
     let mut env = HashMap::new();
     env.insert("TIMEINTERVAL", DataType::String(ti.to_string()));
     functions::fill_env(&mut env);
-    return env;
+    env
 }
 
 pub fn interpret_prog<'a>(
@@ -52,11 +52,10 @@ fn interpret_expr<'a>(
                         ))
                     }
                 },
-                DataType::List(l1) => match b_res {
-                    DataType::List(l2) => {
-                        let mut new_list = l1.clone();
-                        new_list.append(&mut l2.clone());
-                        DataType::List(new_list)
+                DataType::List(mut l1) => match b_res {
+                    DataType::List(mut l2) => {
+                        l1.append(&mut l2);
+                        DataType::List(l1)
                     }
                     _ => {
                         return Err(QueryError::InvalidType(
@@ -66,7 +65,7 @@ fn interpret_expr<'a>(
                 },
                 DataType::String(s1) => match b_res {
                     DataType::String(s2) => {
-                        let mut new_string = s1.clone();
+                        let mut new_string = s1;
                         new_string.push_str(&s2);
                         DataType::String(new_string)
                     }
diff --git a/aw-query/src/lexer.rs b/aw-query/src/lexer.rs
@@ -54,7 +54,7 @@ lexer! {
     r#"False"# => (Token::Bool(false), text),
 
     r#"\"([^\"]|(\\\"))*\""# => (
-        Token::String(text.to_owned()[1..text.len()-1].replace("\\\"", "\"").to_string()),
+        Token::String(text.to_owned()[1..text.len()-1].replace("\\\"", "\"")),
         text
     ),
     r#"[0-9]+[\.]?[0-9]*"# => {
@@ -111,7 +111,7 @@ pub struct Span {
 fn span_in(s: &str, t: &str, l: usize) -> Span {
     let lo = s.as_ptr() as usize - t.as_ptr() as usize;
     Span {
-        lo: lo,
+        lo,
         hi: lo + s.len(),
         line: l,
     }
diff --git a/aw-query/src/lib.rs b/aw-query/src/lib.rs
@@ -17,6 +17,7 @@ mod ast;
 mod functions;
 mod interpret;
 mod lexer;
+#[allow(clippy::match_single_binding, clippy::redundant_closure_call)]
 mod parser;
 
 pub use crate::datatype::DataType;
@@ -46,7 +47,7 @@ impl fmt::Display for QueryError {
     }
 }
 
-pub fn query<'a>(code: &str, ti: &TimeInterval, ds: &Datastore) -> Result<DataType, QueryError> {
+pub fn query(code: &str, ti: &TimeInterval, ds: &Datastore) -> Result<DataType, QueryError> {
     let lexer = lexer::Lexer::new(code);
     let program = match parser::parse(lexer) {
         Ok(p) => p,
diff --git a/aw-query/src/parser.rs b/aw-query/src/parser.rs

Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,9 @@ pub enum DataType {`
`27`	`27`	`Function(String, functions::QueryFn),`
`28`	`28`	`}`
`29`	`29`
	`30`	`+#[allow(clippy::trivially_copy_pass_by_ref)]`
`30`	`31`	`fn serialize_function<S>(`
`31`		`- _element: &String,`
	`32`	`+ _element: &str,`
`32`	`33`	`_fun: &functions::QueryFn,`
`33`	`34`	`_serializer: S,`
`34`	`35`	`) -> Result<S::Ok, S::Error>`
`@@ -132,7 +133,7 @@ impl TryFrom<&DataType> for Vec<String> {`
`132`	`133`	`let s: String = (&string).try_into()?;`
`133`	`134`	`strings.push(s);`
`134`	`135`	`}`
`135`		`- return Ok(strings);`
	`136`	`+ Ok(strings)`
`136`	`137`	`}`
`137`	`138`	`}`
`138`	`139`
`@@ -152,7 +153,7 @@ impl TryFrom<&DataType> for Vec<Event> {`
`152`	`153`	`}`
`153`	`154`	`}`
`154`	`155`	`}`
`155`		`- return Ok(events);`
	`156`	`+ Ok(events)`
`156`	`157`	`}`
`157`	`158`	`}`
`158`	`159`
`@@ -184,7 +185,7 @@ impl TryFrom<&DataType> for Vec<(String, Rule)> {`
`184`	`185`	`}`
`185`	`186`	`}`
`186`	`187`	`}`
`187`		`- return Ok(lists);`
	`188`	`+ Ok(lists)`
`188`	`189`	`}`
`189`	`190`	`}`
`190`	`191`
`@@ -216,7 +217,7 @@ impl TryFrom<&DataType> for Vec<(Vec<String>, Rule)> {`
`216`	`217`	`}`
`217`	`218`	`}`
`218`	`219`	`}`
`219`		`- return Ok(lists);`
	`220`	`+ Ok(lists)`
`220`	`221`	`}`
`221`	`222`	`}`
`222`	`223`
`@@ -255,7 +256,7 @@ impl TryFrom<&DataType> for Value {`
`255`	`256`	`for value in tagged_values.drain(..) {`
`256`	`257`	`values.push((&value).try_into()?);`
`257`	`258`	`}`
`258`		`- return Ok(Value::Array(values));`
	`259`	`+ Ok(Value::Array(values))`
`259`	`260`	`}`
`260`	`261`	`ref invalid_type => Err(QueryError::InvalidFunctionParameters(format!(`
`261`	`262`	`"Query2 support for parsing values is limited, does not support parsing {:?}",`
`@@ -273,7 +274,7 @@ impl TryFrom<&DataType> for Vec<Value> {`
`273`	`274`	`for value in tagged_values.drain(..) {`
`274`	`275`	`values.push((&value).try_into()?);`
`275`	`276`	`}`
`276`		`- return Ok(values);`
	`277`	`+ Ok(values)`
`277`	`278`	`}`
`278`	`279`	`}`
`279`	`280`
`@@ -307,7 +308,7 @@ impl TryFrom<&DataType> for Rule {`
`307`	`308`	`}`
`308`	`309`	`};`
`309`	`310`	`if rtype == "none" {`
`310`		`- return Ok(Self::None);`
	`311`	`+ Ok(Self::None)`
`311`	`312`	`} else if rtype == "regex" {`
`312`	`313`	`let regex_val = match obj.get("regex") {`
`313`	`314`	`Some(regex_val) => regex_val,`
`@@ -346,12 +347,12 @@ impl TryFrom<&DataType> for Rule {`
`346`	`347`	`)))`
`347`	`348`	`}`
`348`	`349`	`};`
`349`		`- return Ok(Self::Regex(regex_rule));`
	`350`	`+ Ok(Self::Regex(regex_rule))`
`350`	`351`	`} else {`
`351`		`- return Err(QueryError::InvalidFunctionParameters(format!(`
	`352`	`+ Err(QueryError::InvalidFunctionParameters(format!(`
`352`	`353`	`"Unknown rule type '{}'",`
`353`	`354`	`rtype`
`354`		`- )));`
	`355`	`+ )))`
`355`	`356`	`}`
`356`	`357`	`}`
`357`	`358`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,6 @@ mod qfunctions {`
`108`	`108`	`use super::validate;`
`109`	`109`	`use crate::DataType;`
`110`	`110`	`use crate::QueryError;`
`111`		`- use aw_transform;`
`112`	`111`
`113`	`112`	`pub fn print(`
`114`	`113`	`args: Vec<DataType>,`
`@@ -118,7 +117,7 @@ mod qfunctions {`
`118`	`117`	`for arg in args {`
`119`	`118`	`info!("{:?}", arg);`
`120`	`119`	`}`
`121`		`- return Ok(DataType::None());`
	`120`	`+ Ok(DataType::None())`
`122`	`121`	`}`
`123`	`122`
`124`	`123`	`pub fn query_bucket(`
`@@ -133,8 +132,8 @@ mod qfunctions {`
`133`	`132`
`134`	`133`	`let events = match ds.get_events(`
`135`	`134`	`bucket_id.as_str(),`
`136`		`- Some(interval.start().clone()),`
`137`		`- Some(interval.end().clone()),`
	`135`	`+ Some(*interval.start()),`
	`136`	`+ Some(*interval.end()),`
`138`	`137`	`None,`
`139`	`138`	`) {`
`140`	`139`	`Ok(events) => events,`
`@@ -149,7 +148,7 @@ mod qfunctions {`
`149`	`148`	`for event in events {`
`150`	`149`	`ret.push(DataType::Event(event));`
`151`	`150`	`}`
`152`		`- return Ok(DataType::List(ret));`
	`151`	`+ Ok(DataType::List(ret))`
`153`	`152`	`}`
`154`	`153`
`155`	`154`	`pub fn query_bucket_names(`
`@@ -171,7 +170,7 @@ mod qfunctions {`
`171`	`170`	`for bucketname in buckets.keys() {`
`172`	`171`	`bucketnames.push(DataType::String(bucketname.to_string()));`
`173`	`172`	`}`
`174`		`- return Ok(DataType::List(bucketnames));`
	`173`	`+ Ok(DataType::List(bucketnames))`
`175`	`174`	`}`
`176`	`175`
`177`	`176`	`pub fn find_bucket(`
`@@ -199,7 +198,7 @@ mod qfunctions {`
`199`	`198`	`)))`
`200`	`199`	`}`
`201`	`200`	`};`
`202`		`- return Ok(DataType::String(bucketname));`
	`201`	`+ Ok(DataType::String(bucketname))`
`203`	`202`	`}`
`204`	`203`
`205`	`204`	`pub fn contains(`
`@@ -210,9 +209,7 @@ mod qfunctions {`
`210`	`209`	`// typecheck`
`211`	`210`	`validate::args_length(&args, 2)?;`
`212`	`211`	`match args[0] {`
`213`		`- DataType::List(ref list) => {`
`214`		`- return Ok(DataType::Bool(list.contains(&args[1])));`
`215`		`- }`
	`212`	`+ DataType::List(ref list) => Ok(DataType::Bool(list.contains(&args[1]))),`
`216`	`213`	`DataType::Dict(ref dict) => {`
`217`	`214`	`let s = match &args[1] {`
`218`	`215`	`DataType::String(s) => s.to_string(),`
`@@ -223,14 +220,12 @@ mod qfunctions {`
`223`	`220`	`)))`
`224`	`221`	`}`
`225`	`222`	`};`
`226`		`- return Ok(DataType::Bool(dict.contains_key(&s)));`
`227`		`- }`
`228`		`- _ => {`
`229`		`- return Err(QueryError::InvalidFunctionParameters(format!(`
`230`		`- "function contains got first argument {:?}, expected type List or Dict",`
`231`		`- args[0]`
`232`		`- )))`
	`223`	`+ Ok(DataType::Bool(dict.contains_key(&s)))`
`233`	`224`	`}`
	`225`	`+ _ => Err(QueryError::InvalidFunctionParameters(format!(`
	`226`	`+ "function contains got first argument {:?}, expected type List or Dict",`
	`227`	`+ args[0]`
	`228`	`+ ))),`
`234`	`229`	`}`
`235`	`230`	`}`
`236`	`231`
`@@ -249,7 +244,7 @@ mod qfunctions {`
`249`	`244`	`for event in flooded_events.drain(..) {`
`250`	`245`	`tagged_flooded_events.push(DataType::Event(event));`
`251`	`246`	`}`
`252`		`- return Ok(DataType::List(tagged_flooded_events));`
	`247`	`+ Ok(DataType::List(tagged_flooded_events))`
`253`	`248`	`}`
`254`	`249`
`255`	`250`	`pub fn categorize(`
`@@ -268,7 +263,7 @@ mod qfunctions {`
`268`	`263`	`for event in flooded_events.drain(..) {`
`269`	`264`	`tagged_flooded_events.push(DataType::Event(event));`
`270`	`265`	`}`
`271`		`- return Ok(DataType::List(tagged_flooded_events));`
	`266`	`+ Ok(DataType::List(tagged_flooded_events))`
`272`	`267`	`}`
`273`	`268`
`274`	`269`	`pub fn tag(`
`@@ -287,7 +282,7 @@ mod qfunctions {`
`287`	`282`	`for event in flooded_events.drain(..) {`
`288`	`283`	`tagged_flooded_events.push(DataType::Event(event));`
`289`	`284`	`}`
`290`		`- return Ok(DataType::List(tagged_flooded_events));`
	`285`	`+ Ok(DataType::List(tagged_flooded_events))`
`291`	`286`	`}`
`292`	`287`
`293`	`288`	`pub fn sort_by_duration(`
`@@ -306,7 +301,7 @@ mod qfunctions {`
`306`	`301`	`for event in sorted_events.drain(..) {`
`307`	`302`	`tagged_sorted_events.push(DataType::Event(event));`
`308`	`303`	`}`
`309`		`- return Ok(DataType::List(tagged_sorted_events));`
	`304`	`+ Ok(DataType::List(tagged_sorted_events))`
`310`	`305`	`}`
`311`	`306`
`312`	`307`	`pub fn limit_events(`
`@@ -326,7 +321,7 @@ mod qfunctions {`
`326`	`321`	`for event in events.drain(0..limit) {`
`327`	`322`	`limited_tagged_events.push(DataType::Event(event));`
`328`	`323`	`}`
`329`		`- return Ok(DataType::List(limited_tagged_events));`
	`324`	`+ Ok(DataType::List(limited_tagged_events))`
`330`	`325`	`}`
`331`	`326`
`332`	`327`	`pub fn sort_by_timestamp(`
`@@ -345,7 +340,7 @@ mod qfunctions {`
`345`	`340`	`for event in sorted_events.drain(..) {`
`346`	`341`	`tagged_sorted_events.push(DataType::Event(event));`
`347`	`342`	`}`
`348`		`- return Ok(DataType::List(tagged_sorted_events));`
	`343`	`+ Ok(DataType::List(tagged_sorted_events))`
`349`	`344`	`}`
`350`	`345`
`351`	`346`	`pub fn sum_durations(`
`@@ -362,9 +357,9 @@ mod qfunctions {`
`362`	`357`	`for event in events.drain(..) {`
`363`	`358`	`sum_durations = sum_durations + event.duration;`
`364`	`359`	`}`
`365`		`- return Ok(DataType::Number(`
	`360`	`+ Ok(DataType::Number(`
`366`	`361`	`(sum_durations.num_milliseconds() as f64) / 1000.0,`
`367`		`- ));`
	`362`	`+ ))`
`368`	`363`	`}`
`369`	`364`
`370`	`365`	`pub fn merge_events_by_keys(`
`@@ -382,7 +377,7 @@ mod qfunctions {`
`382`	`377`	`for event in merged_events.drain(..) {`
`383`	`378`	`merged_tagged_events.push(DataType::Event(event));`
`384`	`379`	`}`
`385`		`- return Ok(DataType::List(merged_tagged_events));`
	`380`	`+ Ok(DataType::List(merged_tagged_events))`
`386`	`381`	`}`
`387`	`382`
`388`	`383`	`pub fn chunk_events_by_key(`
`@@ -400,7 +395,7 @@ mod qfunctions {`
`400`	`395`	`for event in merged_events.drain(..) {`
`401`	`396`	`merged_tagged_events.push(DataType::Event(event));`
`402`	`397`	`}`
`403`		`- return Ok(DataType::List(merged_tagged_events));`
	`398`	`+ Ok(DataType::List(merged_tagged_events))`
`404`	`399`	`}`
`405`	`400`
`406`	`401`	`pub fn filter_keyvals(`
`@@ -419,7 +414,7 @@ mod qfunctions {`
`419`	`414`	`for event in filtered_events.drain(..) {`
`420`	`415`	`filtered_tagged_events.push(DataType::Event(event));`
`421`	`416`	`}`
`422`		`- return Ok(DataType::List(filtered_tagged_events));`
	`417`	`+ Ok(DataType::List(filtered_tagged_events))`
`423`	`418`	`}`
`424`	`419`
`425`	`420`	`pub fn filter_period_intersect(`
`@@ -437,7 +432,7 @@ mod qfunctions {`
`437`	`432`	`for event in filtered_events.drain(..) {`
`438`	`433`	`filtered_tagged_events.push(DataType::Event(event));`
`439`	`434`	`}`
`440`		`- return Ok(DataType::List(filtered_tagged_events));`
	`435`	`+ Ok(DataType::List(filtered_tagged_events))`
`441`	`436`	`}`
`442`	`437`
`443`	`438`	`pub fn split_url_events(`
`@@ -454,7 +449,7 @@ mod qfunctions {`
`454`	`449`	`aw_transform::split_url_event(&mut event);`
`455`	`450`	`tagged_split_url_events.push(DataType::Event(event));`
`456`	`451`	`}`
`457`		`- return Ok(DataType::List(tagged_split_url_events));`
	`452`	`+ Ok(DataType::List(tagged_split_url_events))`
`458`	`453`	`}`
`459`	`454`
`460`	`455`	`pub fn concat(`
`@@ -469,7 +464,7 @@ mod qfunctions {`
`469`	`464`	`event_list.push(DataType::Event(event));`
`470`	`465`	`}`
`471`	`466`	`}`
`472`		`- return Ok(DataType::List(event_list));`
	`467`	`+ Ok(DataType::List(event_list))`
`473`	`468`	`}`
`474`	`469`	`}`
`475`	`470`
`@@ -478,15 +473,15 @@ mod validate {`
`478`	`473`	`use aw_models::TimeInterval;`
`479`	`474`	`use std::collections::HashMap;`
`480`	`475`
`481`		`- pub fn args_length(args: &Vec<DataType>, len: usize) -> Result<(), QueryError> {`
	`476`	`+ pub fn args_length(args: &[DataType], len: usize) -> Result<(), QueryError> {`
`482`	`477`	`if args.len() != len {`
`483`	`478`	`return Err(QueryError::InvalidFunctionParameters(format!(`
`484`	`479`	`"Expected {} parameters in function, got {}",`
`485`	`480`	`len,`
`486`	`481`	`args.len()`
`487`	`482`	`)));`
`488`	`483`	`}`
`489`		`- return Ok(());`
	`484`	`+ Ok(())`
`490`	`485`	`}`
`491`	`486`
`492`	`487`	`pub fn get_timeinterval(env: &HashMap<&str, DataType>) -> Result<TimeInterval, QueryError> {`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ mod ast;`
`17`	`17`	`mod functions;`
`18`	`18`	`mod interpret;`
`19`	`19`	`mod lexer;`
	`20`	`+#[allow(clippy::match_single_binding, clippy::redundant_closure_call)]`
`20`	`21`	`mod parser;`
`21`	`22`
`22`	`23`	`pub use crate::datatype::DataType;`
`@@ -46,7 +47,7 @@ impl fmt::Display for QueryError {`
`46`	`47`	`}`
`47`	`48`	`}`
`48`	`49`
`49`		`-pub fn query<'a>(code: &str, ti: &TimeInterval, ds: &Datastore) -> Result<DataType, QueryError> {`
	`50`	`+pub fn query(code: &str, ti: &TimeInterval, ds: &Datastore) -> Result<DataType, QueryError> {`
`50`	`51`	`let lexer = lexer::Lexer::new(code);`
`51`	`52`	`let program = match parser::parse(lexer) {`
`52`	`53`	`Ok(p) => p,`