Support for colon preceeded placeholders

Author: xitep

src/dialect/mod.rs

@@ -841,6 +841,12 @@ pub trait Dialect: Debug + Any {
         false
     }
 
+    /// Returns true if this dialect allow colon placeholders
+    /// e.g. `SELECT :var` (JPA named parameters)
+    fn supports_colon_placeholder(&self) -> bool {
+        false
+    }
+
     /// Does the dialect support with clause in create index statement?
     /// e.g. `CREATE INDEX idx ON t WITH (key = value, key2)`
     fn supports_create_index_with_clause(&self) -> bool {

src/tokenizer.rs

@@ -1521,6 +1521,11 @@ impl<'a> Tokenizer<'a> {
                     match chars.peek() {
                         Some(':') => self.consume_and_return(chars, Token::DoubleColon),
                         Some('=') => self.consume_and_return(chars, Token::Assignment),
+                        Some(c)
+                            if self.dialect.supports_colon_placeholder() && c.is_alphabetic() =>
+                        {
+                            self.tokenize_colon_preceeded_placeholder(chars).map(Some)
+                        }
                         _ => Ok(Some(Token::Colon)),
                     }
                 }
@@ -1756,6 +1761,30 @@ impl<'a> Tokenizer<'a> {
         }
     }
 
+    /// Tokenizes an identifier followed immediately after a colon,
+    /// aka named query parameter, e.g. `:name`. The next char of the
+    /// processed char stream is to be an alphabetic - panics otherwise.
+    fn tokenize_colon_preceeded_placeholder(
+        &self,
+        chars: &mut State,
+    ) -> Result<Token, TokenizerError> {
+        let mut s = String::with_capacity(16);
+        s.push(':');
+        s.push(chars.next().expect("initial character missing"));
+        while let Some(&ch) = chars.peek() {
+            if ch.is_alphanumeric()
+                || ch == '_'
+                || matches!(ch, '$' if self.dialect.supports_dollar_placeholder())
+            {
+                s.push(ch);
+                chars.next();
+            } else {
+                break;
+            }
+        }
+        Ok(Token::Placeholder(s))
+    }
+
     /// Tokenize dollar preceded value (i.e: a string/placeholder)
     fn tokenize_dollar_preceded_value(&self, chars: &mut State) -> Result<Token, TokenizerError> {
         let mut s = String::new();
@@ -2952,6 +2981,68 @@ mod tests {
         );
     }
 
+    #[test]
+    fn tokenize_colon_placeholder() {
+        #[derive(Debug)]
+        struct TestDialect(bool);
+        impl Dialect for TestDialect {
+            fn supports_colon_placeholder(&self) -> bool {
+                true
+            }
+            fn supports_dollar_placeholder(&self) -> bool {
+                self.0
+            }
+            fn is_identifier_start(&self, ch: char) -> bool {
+                ch.is_alphabetic() || ch == '_'
+            }
+            fn is_identifier_part(&self, ch: char) -> bool {
+                ch.is_alphabetic() || ch.is_ascii_digit() || ch == '_'
+            }
+        }
+
+        let sql = "SELECT :foo FROM bar";
+        let tokens = Tokenizer::new(&TestDialect(false), sql)
+            .tokenize_with_location()
+            .unwrap();
+        assert_eq!(
+            tokens.iter().map(|t| t.token.clone()).collect::<Vec<_>>(),
+            vec![
+                Token::make_keyword("SELECT"),
+                Token::Whitespace(Whitespace::Space),
+                Token::Placeholder(":foo".into()),
+                Token::Whitespace(Whitespace::Space),
+                Token::make_keyword("FROM"),
+                Token::Whitespace(Whitespace::Space),
+                Token::make_word("bar", None)
+            ]
+        );
+        assert_eq!(
+            tokens[2].span,
+            Span::new(Location::of(1, 8), Location::of(1, 12))
+        );
+
+        let sql = "SELECT :foo$bar FROM bar";
+        let tokens = Tokenizer::new(&TestDialect(true), sql)
+            .tokenize_with_location()
+            .unwrap();
+        assert_eq!(
+            tokens.iter().map(|t| t.token.clone()).collect::<Vec<_>>(),
+            vec![
+                Token::make_keyword("SELECT"),
+                Token::Whitespace(Whitespace::Space),
+                Token::Placeholder(":foo$bar".into()),
+                Token::Whitespace(Whitespace::Space),
+                Token::make_keyword("FROM"),
+                Token::Whitespace(Whitespace::Space),
+                Token::make_word("bar", None)
+            ]
+        );
+        assert_eq!(
+            tokens[2].span,
+            Span::new(Location::of(1, 8), Location::of(1, 16))
+        );
+    }
+
     #[test]
     fn tokenize_dollar_placeholder() {
         let sql = String::from("SELECT $$, $$ABC$$, $ABC$, $ABC");