Revert "Support for colon preceeded placeholders"

This reverts commit c54bef6.

Author: xitep

src/dialect/mod.rs

@@ -841,12 +841,6 @@ 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,11 +1521,6 @@ 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)),
                     }
                 }
@@ -1761,30 +1756,6 @@ 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();
@@ -2981,68 +2952,6 @@ 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");