3.0 distinct (#392)

## Usage and product changes

Added distinct stage.

## Implementation

Added keyword to grammar, parsing, and operator enum.

Author: cxdorn

rust/common/token.rs

@@ -73,6 +73,7 @@ string_enum! { Operator
     Limit = "limit",
     Reduce = "reduce",
     Require = "require",
+    Distinct = "distinct",
 }
 
 string_enum! { LogicOperator

rust/parser/pipeline.rs

@@ -30,7 +30,7 @@ use crate::{
             stage::{
                 delete::{Deletable, DeletableKind},
                 fetch::FetchSome,
-                modifier::{Limit, Offset, OrderedVariable, Select, Sort},
+                modifier::{Distinct, Limit, Offset, OrderedVariable, Require, Select, Sort},
                 reduce::{Count, Reducer, Stat},
                 Delete, Fetch, Insert, Match, Operator, Put, Reduce, Stage, Update,
             },
@@ -40,7 +40,6 @@ use crate::{
             fetch::{
                 FetchAttribute, FetchList, FetchObject, FetchObjectBody, FetchObjectEntry, FetchSingle, FetchStream,
             },
-            modifier::Require,
             reduce::ReduceAssign,
         },
         Pipeline,
@@ -351,6 +350,7 @@ pub(super) fn visit_operator_stream(node: Node<'_>) -> Operator {
         Rule::operator_limit => Operator::Limit(visit_operator_limit(child)),
         Rule::operator_reduce => Operator::Reduce(visit_operator_reduce(child)),
         Rule::operator_require => Operator::Require(visit_operator_require(child)),
+        Rule::operator_distinct => Operator::Distinct(visit_operator_distinct(child)),
         _ => unreachable!("{}", TypeQLError::IllegalGrammar { input: child.to_string() }),
     }
 }
@@ -481,3 +481,12 @@ fn visit_operator_require(node: Node<'_>) -> Require {
     debug_assert_eq!(children.try_consume_any(), None);
     Require::new(span, variables)
 }
+
+fn visit_operator_distinct(node: Node<'_>) -> Distinct {
+    debug_assert_eq!(node.as_rule(), Rule::operator_distinct);
+    let span = node.span();
+    let mut children = node.into_children();
+    let _ = children.skip_expected(Rule::DISTINCT);
+    debug_assert_eq!(children.try_consume_any(), None);
+    Distinct::new(span)
+}

rust/parser/typeql.pest

@@ -34,13 +34,14 @@ clause_delete = { DELETE ~ ( statement_deletable ~ SEMICOLON )+ }
 
 // STREAM OPERATORS  ===========================================================
 
-operator_stream = { operator_select | operator_sort | operator_offset | operator_limit | operator_require | operator_reduce }
+operator_stream = { operator_select | operator_sort | operator_distinct | operator_offset | operator_limit | operator_require | operator_reduce }
 
 operator_select = { SELECT ~ vars ~ SEMICOLON }
 operator_sort = { SORT ~ var_order ~ ( COMMA ~ var_order )* ~ SEMICOLON }
 operator_offset = { OFFSET ~ integer_literal ~ SEMICOLON }
 operator_limit = { LIMIT ~ integer_literal ~ SEMICOLON }
 operator_require = { REQUIRE ~ vars ~ SEMICOLON }
+operator_distinct = { DISTINCT ~ SEMICOLON }
 operator_reduce = { REDUCE ~ reduce_assign ~ ( COMMA ~ reduce_assign )* ~ (GROUPBY ~ vars )? ~ SEMICOLON }
 
 var_order = { var ~ ORDER? }
@@ -413,6 +414,7 @@ LIMIT = @{ "limit" ~ WB }
 OFFSET = @{ "offset" ~ WB }
 SORT = @{ "sort" ~ WB }
 REQUIRE = @{ "require" ~ WB }
+DISTINCT = @{ "distinct" ~ WB }
 
 ORDER = ${ ASC | DESC }
 ASC = @{ "asc" ~ WB }

rust/query/pipeline/stage/modifier.rs

@@ -188,6 +188,31 @@ impl fmt::Display for Require {
     }
 }
 
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Distinct {
+    span: Option<Span>,
+}
+
+impl Distinct {
+    pub fn new(span: Option<Span>) -> Self {
+        Self { span }
+    }
+}
+
+impl Spanned for Distinct {
+    fn span(&self) -> Option<Span> {
+        self.span
+    }
+}
+
+impl Pretty for Distinct {}
+
+impl fmt::Display for Distinct {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{};", token::Operator::Distinct)
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub enum Operator {
     Select(Select),
@@ -196,6 +221,7 @@ pub enum Operator {
     Limit(Limit),
     Reduce(Reduce),
     Require(Require),
+    Distinct(Distinct),
 }
 
 impl Spanned for Operator {
@@ -207,6 +233,7 @@ impl Spanned for Operator {
             Self::Limit(inner) => inner.span(),
             Self::Reduce(inner) => inner.span(),
             Self::Require(inner) => inner.span(),
+            Self::Distinct(inner) => inner.span(),
         }
     }
 }
@@ -220,6 +247,7 @@ impl Pretty for Operator {
             Self::Limit(inner) => Pretty::fmt(inner, indent_level, f),
             Self::Reduce(inner) => Pretty::fmt(inner, indent_level, f),
             Self::Require(inner) => Pretty::fmt(inner, indent_level, f),
+            Self::Distinct(inner) => Pretty::fmt(inner, indent_level, f),
         }
     }
 }
@@ -233,6 +261,7 @@ impl fmt::Display for Operator {
             Self::Limit(inner) => fmt::Display::fmt(inner, f),
             Self::Reduce(inner) => fmt::Display::fmt(inner, f),
             Self::Require(inner) => fmt::Display::fmt(inner, f),
+            Self::Distinct(inner) => fmt::Display::fmt(inner, f),
         }
     }
 }