feat(parser): support to parse param in parser

src/sqlparser/src/ast/mod.rs

@@ -359,6 +359,8 @@ pub enum Expr {
     Nested(Box<Expr>),
     /// A literal value, such as string, number, date or NULL
     Value(Value),
+    /// Parameter Symbol e.g. `$1`, `$1::int`
+    Parameter { index: u64 },
     /// 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).
@@ -465,6 +467,7 @@ impl fmt::Display for Expr {
             Expr::Collate { expr, collation } => write!(f, "{} COLLATE {}", expr, collation),
             Expr::Nested(ast) => write!(f, "({})", ast),
             Expr::Value(v) => write!(f, "{}", v),
+            Expr::Parameter { index } => write!(f, "${}", index),
             Expr::TypedString { data_type, value } => {
                 write!(f, "{}", data_type)?;
                 write!(f, " '{}'", &value::escape_single_quote_string(value))

src/sqlparser/src/parser.rs

@@ -569,7 +569,7 @@ impl Parser {
                 self.prev_token();
                 Ok(Expr::Value(self.parse_value()?))
             }
-
+            Token::Parameter(number) => self.parse_param(number),
             Token::LParen => {
                 let expr =
                     if self.parse_keyword(Keyword::SELECT) || self.parse_keyword(Keyword::WITH) {
@@ -603,6 +603,14 @@ impl Parser {
         }
     }
 
+    fn parse_param(&mut self, param: String) -> Result<Expr, ParserError> {
+        Ok(Expr::Parameter {
+            index: param.parse().map_err(|_| {
+                ParserError::ParserError(format!("Parameter symbol has a invalid index {}.", param))
+            })?,
+        })
+    }
+
     /// Parses a field selection expression. See also [`Expr::FieldIdentifier`].
     pub fn parse_struct_selection(&mut self, expr: Expr) -> Result<Expr, ParserError> {
         let mut nested_expr = expr;

src/sqlparser/src/tokenizer.rs

@@ -53,6 +53,8 @@ pub enum Token {
     NationalStringLiteral(String),
     /// Hexadecimal string literal: i.e.: X'deadbeef'
     HexStringLiteral(String),
+    /// Parameter symbols: i.e:  $1, $2
+    Parameter(String),
     /// Comma
     Comma,
     /// Whitespace (space, tab, etc)
@@ -161,6 +163,7 @@ impl fmt::Display for Token {
             Token::NationalStringLiteral(ref s) => write!(f, "N'{}'", s),
             Token::HexStringLiteral(ref s) => write!(f, "X'{}'", s),
             Token::CstyleEscapesString(ref s) => write!(f, "E'{}'", s),
+            Token::Parameter(ref s) => write!(f, "${}", s),
             Token::Comma => f.write_str(","),
             Token::Whitespace(ws) => write!(f, "{}", ws),
             Token::DoubleEq => f.write_str("=="),
@@ -359,7 +362,6 @@ impl<'a> Tokenizer<'a> {
 
     /// Get the next token or return None
     fn next_token(&self, chars: &mut Peekable<Chars<'_>>) -> Result<Option<Token>, TokenizerError> {
-        // println!("next_token: {:?}", chars.peek());
         match chars.peek() {
             Some(&ch) => match ch {
                 ' ' => self.consume_and_return(chars, Token::Whitespace(Whitespace::Space)),
@@ -611,6 +613,13 @@ impl<'a> Tokenizer<'a> {
                         _ => Ok(Some(Token::Colon)),
                     }
                 }
+                '$' => {
+                    if let Some(parameter) = self.tokenize_parameter(chars) {
+                        Ok(Some(parameter))
+                    } else {
+                        Ok(Some(Token::Char('$')))
+                    }
+                }
                 ';' => self.consume_and_return(chars, Token::SemiColon),
                 '\\' => self.consume_and_return(chars, Token::Backslash),
                 '[' => self.consume_and_return(chars, Token::LBracket),
@@ -790,6 +799,17 @@ impl<'a> Tokenizer<'a> {
         chars.next();
         Ok(Some(t))
     }
+
+    fn tokenize_parameter(&self, chars: &mut Peekable<Chars<'_>>) -> Option<Token> {
+        chars.next(); // consume '$'
+
+        let s = peeking_take_while(chars, |ch| ch.is_ascii_digit());
+        if s.is_empty() {
+            None
+        } else {
+            Some(Token::Parameter(s))
+        }
+    }
 }
 
 /// Read from `chars` until `predicate` returns `false` or EOF is hit.

src/sqlparser/tests/sqlparser_postgres.rs

@@ -1049,3 +1049,53 @@ fn parse_array() {
         )),
     );
 }
+
+#[test]
+fn parse_param_symbol() {
+    let select = verified_only_select("SELECT $1");
+    assert_eq!(
+        SelectItem::UnnamedExpr(Expr::Parameter { index: 1 }),
+        select.projection[0]
+    );
+
+    let select = verified_only_select("SELECT *, $2 FROM t WHERE a = $1");
+    assert_eq!(
+        Expr::BinaryOp {
+            left: Box::new(Expr::Identifier(Ident::new_unchecked("a"))),
+            op: BinaryOperator::Eq,
+            right: Box::new(Expr::Parameter { index: 1 })
+        },
+        select.selection.unwrap()
+    );
+    assert_eq!(
+        SelectItem::UnnamedExpr(Expr::Parameter { index: 2 }),
+        select.projection[1]
+    );
+
+    let select = verified_only_select("SELECT CAST($4096 AS INT)");
+    assert_eq!(
+        SelectItem::UnnamedExpr(Expr::Cast {
+            expr: Box::new(Expr::Parameter { index: 4096 }),
+            data_type: DataType::Int
+        }),
+        select.projection[0]
+    );
+
+    let select = verified_only_select("SELECT * FROM t WHERE a = CAST($1024 AS BIGINT)");
+    assert_eq!(
+        Expr::BinaryOp {
+            left: Box::new(Expr::Identifier(Ident::new_unchecked("a"))),
+            op: BinaryOperator::Eq,
+            right: Box::new(Expr::Cast {
+                expr: Box::new(Expr::Parameter { index: 1024 }),
+                data_type: DataType::BigInt
+            })
+        },
+        select.selection.unwrap()
+    );
+
+    let query = verified_query("VALUES ($1)");
+    if let SetExpr::Values(values) = query.body {
+        assert_eq!(values.0[0][0], Expr::Parameter { index: 1 });
+    }
+}