WIP: Parse positional parameters

Author: JLDLaughlin

src/parser.rs

@@ -256,7 +256,8 @@ impl Parser {
                     expr: Box::new(self.parse_subexpr(Self::PLUS_MINUS_PREC)?),
                 })
             }
-            Token::Number(_)
+            Token::Parameter(_)
+            | Token::Number(_)
             | Token::SingleQuotedString(_)
             | Token::NationalStringLiteral(_)
             | Token::HexStringLiteral(_) => {

src/tokenizer.rs

@@ -38,6 +38,10 @@ pub enum Token {
     NationalStringLiteral(String),
     /// Hexadecimal string literal: i.e.: X'deadbeef'
     HexStringLiteral(String),
+    /// An unsigned numeric literal representing positional
+    /// parameters like $1, $2, etc. in prepared statements and
+    /// function definitions
+    Parameter(String),
     /// Comma
     Comma,
     /// Whitespace (space, tab, etc)
@@ -99,6 +103,7 @@ impl fmt::Display for Token {
             Token::SingleQuotedString(ref s) => write!(f, "'{}'", s),
             Token::NationalStringLiteral(ref s) => write!(f, "N'{}'", s),
             Token::HexStringLiteral(ref s) => write!(f, "X'{}'", s),
+            Token::Parameter(ref s) => write!(f, "$'{}'", s),
             Token::Comma => f.write_str(","),
             Token::Whitespace(ws) => write!(f, "{}", ws),
             Token::Eq => f.write_str("="),
@@ -249,6 +254,7 @@ impl<'a> Tokenizer<'a> {
                 Token::Word(w) if w.quote_style != None => self.col += w.value.len() as u64 + 2,
                 Token::Number(s) => self.col += s.len() as u64,
                 Token::SingleQuotedString(s) => self.col += s.len() as u64,
+                Token::Parameter(s) => self.col += s.len() as u64,
                 _ => self.col += 1,
             }
 
@@ -259,7 +265,7 @@ 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());
+//        println!("next_token: {:?}", chars.peek());
         match chars.peek() {
             Some(&ch) => match ch {
                 ' ' => self.consume_and_return(chars, Token::Whitespace(Whitespace::Space)),
@@ -415,6 +421,7 @@ impl<'a> Tokenizer<'a> {
                 '&' => self.consume_and_return(chars, Token::Ampersand),
                 '{' => self.consume_and_return(chars, Token::LBrace),
                 '}' => self.consume_and_return(chars, Token::RBrace),
+                '$' => self.tokenize_positional_parameter(chars),
                 other => self.consume_and_return(chars, Token::Char(other)),
             },
             None => Ok(None),
@@ -490,6 +497,27 @@ impl<'a> Tokenizer<'a> {
         }
     }
 
+    /// PostgreSQL supports positional parameters (like $1, $2, etc.) for prepared statements
+    /// and function definitions.
+    /// Grab the positional argument following a $ to parse it.
+    fn tokenize_positional_parameter(&self, chars: &mut Peekable<Chars<'_>>) -> Result<Option<Token>, TokenizerError> {
+        assert_eq!(Some(&'$'), chars.peek());
+        chars.next(); // throw away $
+
+        // Right now, following block copied from number parsing above...
+        // TODO: https://jakewheat.github.io/sql-overview/sql-2011-foundation-grammar.html#unsigned-numeric-literal
+        let position = peeking_take_while(chars, |ch| match ch {
+            '0'..='9' | '$' => true,
+            _ => false,
+        });
+        // End copied block
+
+        let new_token = Token::Parameter(position);
+        println!("new token: {:#?}", new_token);
+
+        Ok(Some(new_token))
+    }
+
     fn consume_and_return(
         &self,
         chars: &mut Peekable<Chars<'_>>,