Add support for named argument function

This commit support functions with argument names.
the format is : "Select * from ( a => exp, b=> exp2 .. )

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

name arugment function describe here

Author: eyalsatori

src/ast/mod.rs

@@ -191,7 +191,10 @@ pub enum Expr {
         right: Box<Expr>,
     },
     /// Unary operation e.g. `NOT foo`
-    UnaryOp { op: UnaryOperator, expr: Box<Expr> },
+    UnaryOp {
+        op: UnaryOperator,
+        expr: Box<Expr>,
+    },
     /// CAST an expression to a different data type e.g. `CAST(foo AS VARCHAR(123))`
     Cast {
         expr: Box<Expr>,
@@ -213,7 +216,10 @@ pub enum Expr {
     /// A constant of form `<data_type> 'value'`.
     /// This can represent ANSI SQL `DATE`, `TIME`, and `TIMESTAMP` literals (such as `DATE '2020-01-01'`),
     /// as well as constants of other types (a non-standard PostgreSQL extension).
-    TypedString { data_type: DataType, value: String },
+    TypedString {
+        data_type: DataType,
+        value: String,
+    },
     /// Scalar function call e.g. `LEFT(foo, 5)`
     Function(Function),
     /// `CASE [<operand>] WHEN <condition> THEN <result> ... [ELSE <result>] END`
@@ -235,6 +241,11 @@ pub enum Expr {
     Subquery(Box<Query>),
     /// The `LISTAGG` function `SELECT LISTAGG(...) WITHIN GROUP (ORDER BY ...)`
     ListAgg(ListAgg),
+    // Argument with name (Name=>agument)
+    NamedArgument {
+        name: ObjectName,
+        value: Box<Expr>,
+    },
 }
 
 impl fmt::Display for Expr {
@@ -315,6 +326,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 object_name = self.parse_object_name()?;
+
+                        // the RArrow ('=>')
+                        let _ = self.next_token();
+
+                        Ok(Expr::NamedArgument {
+                            name: object_name,
+                            value: Box::new(self.parse_expr()?),
+                        })
+                    }
                     _ => Ok(Expr::Identifier(w.to_ident())),
                 },
             }, // End of Token::Word

src/tokenizer.rs

@@ -96,6 +96,8 @@ pub enum Token {
     LBrace,
     /// Right brace `}`
     RBrace,
+    /// Right Arrow `=>`
+    RArrow,
 }
 
 impl fmt::Display for Token {
@@ -136,6 +138,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("=>"),
         }
     }
 }
@@ -318,7 +321,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);
@@ -395,7 +398,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
@@ -761,6 +770,23 @@ mod tests {
         compare(expected, tokens);
     }
 
+    #[test]
+    fn tokenize_rigth_arrow() {
+        let sql = String::from("FUCNTION(key=>value)");
+        let dialect = GenericDialect {};
+        let mut tokenizer = Tokenizer::new(&dialect, &sql);
+        let tokens = tokenizer.tokenize().unwrap();
+        let expected = vec![
+            Token::make_word("FUCNTION", 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: ObjectName(vec![Ident::new("a")]),
+                    value: Box::new(Expr::Value(Value::SingleQuotedString("1".to_owned())))
+                },
+                Expr::NamedArgument {
+                    name: ObjectName(vec![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), \