Implement DEDUP function (gluesql#1430)

Removes consecutive repeated elements 
e.g.
SELECT DEDUP(CAST('[0, 1, 2, 2, 3, 4, 4]') AS List)
-- > [0, 1, 2, 3, 4]

core/src/ast/function.rs

@@ -208,6 +208,7 @@ pub enum Function {
         end_index: Expr,
         values: Option<Expr>,
     },
+    Dedup(Expr),
 }
 
 impl ToSql for Function {
@@ -488,6 +489,7 @@ impl ToSql for Function {
                     end_index.to_sql(),
                 ),
             },
+            Function::Dedup(list) => format!("DEDUP({})", list.to_sql()),
         }
     }
 }
@@ -1349,6 +1351,14 @@ mod tests {
             }))
             .to_sql()
         );
+
+        assert_eq!(
+            r#"DEDUP("list")"#,
+            &Expr::Function(Box::new(Function::Dedup(Expr::Identifier(
+                "list".to_owned()
+            ))))
+            .to_sql(),
+        )
     }
 
     #[test]

core/src/executor/evaluate/function.rs

@@ -1050,3 +1050,13 @@ pub fn splice<'a>(
 
     Continue(Evaluated::Value(Value::List(result)))
 }
+
+pub fn dedup<'a>(list: Evaluated<'_>) -> ControlFlow<Evaluated<'a>> {
+    match list.try_into().break_if_null()? {
+        Value::List(mut list) => {
+            list.dedup();
+            Continue(Evaluated::Value(Value::List(list)))
+        }
+        _ => Err(EvaluateError::ListTypeRequired.into()).into_control_flow(),
+    }
+}

core/src/executor/evaluate/mod.rs

@@ -691,6 +691,7 @@ async fn evaluate_function<'a, 'b: 'a, 'c: 'a, T: GStore>(
             };
             f::splice(name, list_data, begin_index, end_index, values)
         }
+        Function::Dedup(list) => f::dedup(eval(list).await?),
     };
 
     match result {

core/src/plan/expr/function.rs

@@ -61,7 +61,8 @@ impl Function {
             | Self::GetY(expr)
             | Self::IsEmpty(expr)
             | Self::Sort { expr, order: None }
-            | Self::Values(expr) => Exprs::Single([expr].into_iter()),
+            | Self::Values(expr)
+            | Self::Dedup(expr) => Exprs::Single([expr].into_iter()),
             Self::Left { expr, size: expr2 }
             | Self::Right { expr, size: expr2 }
             | Self::Lpad {
@@ -291,6 +292,8 @@ mod tests {
         test(r#"SIGN(3.0)"#, &["3.0"]);
         test(r#"SIGN(-3.0)"#, &["-3.0"]);
 
+        test(r#"DEDUP(list)"#, &["list"]);
+
         // Double
         test(r#"LEFT("hello", 2)"#, &[r#""hello""#, "2"]);
         test(r#"RIGHT("hello", 2)"#, &[r#""hello""#, "2"]);

core/src/translate/function.rs

@@ -656,6 +656,11 @@ pub fn translate_function(sql_function: &SqlFunction) -> Result<Expr> {
                 values,
             })))
         }
+        "DEDUP" => {
+            check_len(name, args.len(), 1)?;
+            let list = translate_expr(args[0])?;
+            Ok(Expr::Function(Box::new(Function::Dedup(list))))
+        }
         _ => {
             let exprs = args
                 .into_iter()

test-suite/src/function/dedup.rs

@@ -0,0 +1,29 @@
+use {
+    crate::*,
+    gluesql_core::{executor::EvaluateError, prelude::Value::*},
+};
+
+test_case!(dedup, {
+    let g = get_tester!();
+
+    g.named_test(
+        "DEDUP(CAST('[1, 2, 3, 3, 4, 5, 5]' AS List)) should return '[1, 2, 3, 4, 5]'",
+        "SELECT DEDUP(CAST('[1, 2, 3, 3, 4, 5, 5]' AS List)) as actual",
+        Ok(select!(actual List; vec![I64(1), I64(2), I64(3), I64(4), I64(5)])),
+    )
+    .await;
+
+    g.named_test(
+        "DEDUP(CAST('['1', 1, '1']' AS List)) should return '['1', 1]'",
+        r#"SELECT DEDUP(CAST('["1", 1, 1, "1", "1"]' AS List)) as actual"#,
+        Ok(select!(actual List; vec![Str("1".to_owned()), I64(1), Str("1".to_owned())])),
+    )
+    .await;
+
+    g.named_test(
+        "DEDUP with invalid value should return EvaluateError::ListTypeRequired",
+        "SELECT DEDUP(1) AS actual",
+        Err(EvaluateError::ListTypeRequired.into()),
+    )
+    .await;
+});

test-suite/src/function/mod.rs

@@ -8,6 +8,7 @@ pub mod chr;
 pub mod coalesce;
 pub mod concat;
 pub mod concat_ws;
+pub mod dedup;
 pub mod degrees;
 pub mod div_mod;
 pub mod entries;

test-suite/src/lib.rs

@@ -217,6 +217,7 @@ macro_rules! generate_store_tests {
         glue!(function_take, function::take::take);
         glue!(column_alias, column_alias::column_alias);
         glue!(function_splice, function::splice::splice);
+        glue!(function_dedup, function::dedup::dedup);
 
         // ast-builder
         glue!(ast_builder_basic, ast_builder::basic::basic);