Introduce Collector variant of Reducer to accomodate the unimplemented list reducer (#436)

## Product change and motivation
It was placed under Stat, which it is not and caused confusion & crashes in core.

Author: krishnangovindraj

rust/common/token.rs

@@ -157,14 +157,20 @@ string_enum! { Annotation
     Values = "values",
 }
 
-string_enum! { ReduceOperator
+string_enum! { ReduceOperatorCount
     Count = "count",
+}
+
+string_enum! { ReduceOperatorStat
     Max = "max",
     Mean = "mean",
     Median = "median",
     Min = "min",
     Std = "std",
     Sum = "sum",
+}
+
+string_enum! { ReduceOperatorCollect
     List = "list",
 }
 

rust/parser/pipeline.rs

@@ -17,7 +17,7 @@ use super::{
 use crate::{
     common::{
         error::TypeQLError,
-        token::{Order, ReduceOperator},
+        token::{Order, ReduceOperatorCollect, ReduceOperatorStat},
         Spanned,
     },
     parser::define::function::visit_function_block,
@@ -28,7 +28,7 @@ use crate::{
                 delete::{Deletable, DeletableKind},
                 fetch::FetchSome,
                 modifier::{Distinct, Limit, Offset, OrderedVariable, Require, Select, Sort},
-                reduce::{Count, Reducer, Stat},
+                reduce::{Collect, Count, Reducer, Stat},
                 Delete, Fetch, Insert, Match, Operator, Put, Reduce, Stage, Update,
             },
             Preamble,
@@ -411,32 +411,41 @@ pub(crate) fn visit_reducer(node: Node<'_>) -> Reducer {
     let keyword = children.consume_any();
     match keyword.as_rule() {
         Rule::COUNT => Reducer::Count(Count::new(span, children.try_consume_expected(Rule::var).map(visit_var))),
-        Rule::MAX => {
-            Reducer::Stat(Stat::new(span, ReduceOperator::Max, visit_var(children.consume_expected(Rule::var))))
+        Rule::reducer_stat => {
+            let operator = visit_reducer_stat(keyword);
+            Reducer::Stat(Stat::new(span, operator, visit_var(children.consume_expected(Rule::var))))
         }
-        Rule::MIN => {
-            Reducer::Stat(Stat::new(span, ReduceOperator::Min, visit_var(children.consume_expected(Rule::var))))
-        }
-        Rule::MEAN => {
-            Reducer::Stat(Stat::new(span, ReduceOperator::Mean, visit_var(children.consume_expected(Rule::var))))
-        }
-        Rule::MEDIAN => {
-            Reducer::Stat(Stat::new(span, ReduceOperator::Median, visit_var(children.consume_expected(Rule::var))))
-        }
-        Rule::STD => {
-            Reducer::Stat(Stat::new(span, ReduceOperator::Std, visit_var(children.consume_expected(Rule::var))))
-        }
-        Rule::SUM => {
-            Reducer::Stat(Stat::new(span, ReduceOperator::Sum, visit_var(children.consume_expected(Rule::var))))
-        }
-        Rule::LIST => {
-            // TODO      vvvv rename
-            Reducer::Stat(Stat::new(span, ReduceOperator::List, visit_var(children.consume_expected(Rule::var))))
+        Rule::reducer_collect => {
+            let operator = visit_reducer_collect(keyword);
+            Reducer::Collect(Collect::new(span, operator, visit_var(children.consume_expected(Rule::var))))
         }
         _ => unreachable!("{}", TypeQLError::IllegalGrammar { input: keyword.as_str().to_owned() }),
     }
 }
 
+fn visit_reducer_stat(node: Node<'_>) -> ReduceOperatorStat {
+    debug_assert_eq!(node.as_rule(), Rule::reducer_stat);
+    let child = node.into_child();
+    match child.as_rule() {
+        Rule::MAX => ReduceOperatorStat::Max,
+        Rule::MIN => ReduceOperatorStat::Min,
+        Rule::MEAN => ReduceOperatorStat::Mean,
+        Rule::MEDIAN => ReduceOperatorStat::Median,
+        Rule::STD => ReduceOperatorStat::Std,
+        Rule::SUM => ReduceOperatorStat::Sum,
+        _ => unreachable!("{}", TypeQLError::IllegalGrammar { input: child.as_str().to_owned() }),
+    }
+}
+
+fn visit_reducer_collect(node: Node<'_>) -> ReduceOperatorCollect {
+    debug_assert_eq!(node.as_rule(), Rule::reducer_collect);
+    let child = node.into_child();
+    match child.as_rule() {
+        Rule::LIST => ReduceOperatorCollect::List,
+        _ => unreachable!("{}", TypeQLError::IllegalGrammar { input: child.as_str().to_owned() }),
+    }
+}
+
 fn visit_operator_select(node: Node<'_>) -> Select {
     debug_assert_eq!(node.as_rule(), Rule::operator_select);
     let span = node.span();

rust/parser/typeql.pest

@@ -53,14 +53,11 @@ reduce_assign = { ( reduce_assignment_var ~ ASSIGN ~ reducer ) }
 
 reduce_assignment_var = { var_optional | var }
 reducer = { COUNT ~ ( PAREN_OPEN ~ var ~ PAREN_CLOSE )?
-          | MAX ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
-          | MIN ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
-          | MEAN ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
-          | MEDIAN ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
-          | STD ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
-          | SUM ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
-          | LIST ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
+          | reducer_stat ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
+          | reducer_collect ~ PAREN_OPEN ~ var ~ PAREN_CLOSE
           }
+reducer_stat = { MAX | MIN | MEAN | MEDIAN | STD | SUM }
+reducer_collect = { LIST }
 
 // QUERY PATTERNS ==============================================================
 

rust/query/pipeline/stage/reduce.rs

@@ -82,13 +82,15 @@ impl fmt::Display for ReduceAssign {
 pub enum Reducer {
     Count(Count),
     Stat(Stat),
+    Collect(Collect),
 }
 
 impl Pretty for Reducer {
     fn fmt(&self, indent_level: usize, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Count(inner) => Pretty::fmt(inner, indent_level, f),
             Self::Stat(inner) => Pretty::fmt(inner, indent_level, f),
+            Self::Collect(inner) => Pretty::fmt(inner, indent_level, f),
         }
     }
 }
@@ -98,6 +100,7 @@ impl fmt::Display for Reducer {
         match self {
             Self::Count(inner) => fmt::Display::fmt(inner, f),
             Self::Stat(inner) => fmt::Display::fmt(inner, f),
+            Self::Collect(inner) => fmt::Display::fmt(inner, f),
         }
     }
 }
@@ -124,7 +127,7 @@ impl Pretty for Count {}
 
 impl fmt::Display for Count {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", token::ReduceOperator::Count)?;
+        write!(f, "{}", token::ReduceOperatorCount::Count)?;
         if let Some(variable) = &self.variable {
             write!(f, "({})", variable)?;
         }
@@ -135,12 +138,12 @@ impl fmt::Display for Count {
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Stat {
     pub span: Option<Span>,
-    pub reduce_operator: token::ReduceOperator,
+    pub reduce_operator: token::ReduceOperatorStat,
     pub variable: Variable,
 }
 
 impl Stat {
-    pub fn new(span: Option<Span>, aggregate: token::ReduceOperator, variable: Variable) -> Self {
+    pub fn new(span: Option<Span>, aggregate: token::ReduceOperatorStat, variable: Variable) -> Self {
         Self { span, reduce_operator: aggregate, variable }
     }
 }
@@ -158,3 +161,30 @@ impl fmt::Display for Stat {
         write!(f, "{}({})", self.reduce_operator, self.variable)
     }
 }
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Collect {
+    pub span: Option<Span>,
+    pub reduce_operator: token::ReduceOperatorCollect,
+    pub variable: Variable,
+}
+
+impl Collect {
+    pub fn new(span: Option<Span>, aggregate: token::ReduceOperatorCollect, variable: Variable) -> Self {
+        Self { span, reduce_operator: aggregate, variable }
+    }
+}
+
+impl Spanned for Collect {
+    fn span(&self) -> Option<Span> {
+        self.span
+    }
+}
+
+impl Pretty for Collect {}
+
+impl fmt::Display for Collect {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}({})", self.reduce_operator, self.variable)
+    }
+}