Add support for named argument function

This commit support functions with argument names.
the format is :
"Select some_function( a => exp, b => exp2 .. ) FROM table1
OR
"select * from table(function(a => exp)) f;"

see:
https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#named-argument-assignment-token
or example is snwflake db :
https://docs.snowflake.com/en/sql-reference/functions/flatten.html

Author: eyalsatori

src/ast/mod.rs

@@ -235,6 +235,8 @@ pub enum Expr {
     Subquery(Box<Query>),
     /// The `LISTAGG` function `SELECT LISTAGG(...) WITHIN GROUP (ORDER BY ...)`
     ListAgg(ListAgg),
+    /// Argument with name (Name=>argument)
+    NamedArgument { name: Ident, value: Box<Expr> },
 }
 
 impl fmt::Display for Expr {
@@ -315,6 +317,7 @@ impl fmt::Display for Expr {
             Expr::Exists(s) => write!(f, "EXISTS ({})", s),
             Expr::Subquery(s) => write!(f, "({})", s),
             Expr::ListAgg(listagg) => write!(f, "{}", listagg),
+            Expr::NamedArgument { name, value } => write!(f, "{} => {}", name, value),
         }
     }
 }

src/parser.rs

@@ -276,6 +276,18 @@ impl Parser {
                             Ok(Expr::CompoundIdentifier(id_parts))
                         }
                     }
+                    Token::RArrow => {
+                        self.prev_token();
+                        let ident = self.parse_identifier()?;
+
+                        // the RArrow ('=>')
+                        let _ = self.next_token();
+
+                        Ok(Expr::NamedArgument {
+                            name: ident,
+                            value: Box::new(self.parse_expr()?),
+                        })
+                    }
                     _ => Ok(Expr::Identifier(w.to_ident())),
                 },
             }, // End of Token::Word

src/tokenizer.rs

@@ -99,6 +99,8 @@ pub enum Token {
     LBrace,
     /// Right brace `}`
     RBrace,
+    /// Right Arrow `=>`
+    RArrow,
 }
 
 impl fmt::Display for Token {
@@ -139,6 +141,7 @@ impl fmt::Display for Token {
             Token::Pipe => f.write_str("|"),
             Token::LBrace => f.write_str("{"),
             Token::RBrace => f.write_str("}"),
+            Token::RArrow => f.write_str("=>"),
         }
     }
 }
@@ -323,7 +326,7 @@ impl<'a> Tokenizer<'a> {
                         }
                     }
                 }
-                // identifier or keyword
+                // identifier or Keyword
                 ch if self.dialect.is_identifier_start(ch) => {
                     chars.next(); // consume the first char
                     let s = self.tokenize_word(ch, chars);
@@ -400,7 +403,13 @@ impl<'a> Tokenizer<'a> {
                         _ => Ok(Some(Token::Pipe)),
                     }
                 }
-                '=' => self.consume_and_return(chars, Token::Eq),
+                '=' => {
+                    chars.next(); // consume
+                    match chars.peek() {
+                        Some('>') => self.consume_and_return(chars, Token::RArrow),
+                        _ => Ok(Some(Token::Eq)),
+                    }
+                }
                 '.' => self.consume_and_return(chars, Token::Period),
                 '!' => {
                     chars.next(); // consume
@@ -766,6 +775,23 @@ mod tests {
         compare(expected, tokens);
     }
 
+    #[test]
+    fn tokenize_right_arrow() {
+        let sql = String::from("FUNCTION(key=>value)");
+        let dialect = GenericDialect {};
+        let mut tokenizer = Tokenizer::new(&dialect, &sql);
+        let tokens = tokenizer.tokenize().unwrap();
+        let expected = vec![
+            Token::make_word("FUNCTION", None),
+            Token::LParen,
+            Token::make_word("key", None),
+            Token::RArrow,
+            Token::make_word("value", None),
+            Token::RParen,
+        ];
+        compare(expected, tokens);
+    }
+
     #[test]
     fn tokenize_is_null() {
         let sql = String::from("a IS NULL");

tests/sqlparser_common.rs

@@ -1597,6 +1597,30 @@ fn parse_scalar_function_in_projection() {
     );
 }
 
+#[test]
+fn parse_named_argument_function() {
+    let sql = "SELECT FUN(a => '1', b => '2') FROM foo";
+    let select = verified_only_select(sql);
+    assert_eq!(
+        &Expr::Function(Function {
+            name: ObjectName(vec![Ident::new("FUN")]),
+            args: vec![
+                Expr::NamedArgument {
+                    name: Ident::new("a"),
+                    value: Box::new(Expr::Value(Value::SingleQuotedString("1".to_owned())))
+                },
+                Expr::NamedArgument {
+                    name: Ident::new("b"),
+                    value: Box::new(Expr::Value(Value::SingleQuotedString("2".to_owned())))
+                }
+            ],
+            over: None,
+            distinct: false,
+        }),
+        expr_from_projection(only(&select.projection))
+    );
+}
+
 #[test]
 fn parse_window_functions() {
     let sql = "SELECT row_number() OVER (ORDER BY dt DESC), \