add support for single-quoted identifiers

This does not support single-quoted table names, but supports the most common case of

    select tablename.'column' from tablename

Author: lovasoa

src/parser/mod.rs

@@ -618,18 +618,30 @@ impl<'a> Parser<'a> {
 
         let next_token = self.next_token();
         match next_token.token {
-            Token::Word(w) if self.peek_token().token == Token::Period => {
-                let mut id_parts: Vec<Ident> = vec![w.to_ident()];
-
-                while self.consume_token(&Token::Period) {
-                    let next_token = self.next_token();
-                    match next_token.token {
-                        Token::Word(w) => id_parts.push(w.to_ident()),
-                        Token::Mul => {
-                            return Ok(WildcardExpr::QualifiedWildcard(ObjectName(id_parts)));
-                        }
-                        _ => {
-                            return self.expected("an identifier or a '*' after '.'", next_token);
+            t @ (Token::Word(_) | Token::SingleQuotedString(_)) => {
+                if self.peek_token().token == Token::Period {
+                    let mut id_parts: Vec<Ident> = vec![match t {
+                        Token::Word(w) => w.to_ident(),
+                        Token::SingleQuotedString(s) => Ident::with_quote('\'', s),
+                        Token::DoubleQuotedString(s) => Ident::with_quote('"', s),
+                        _ => unreachable!(), // We matched above
+                    }];
+
+                    while self.consume_token(&Token::Period) {
+                        let next_token = self.next_token();
+                        match next_token.token {
+                            Token::Word(w) => id_parts.push(w.to_ident()),
+                            Token::SingleQuotedString(s) => {
+                                // SQLite has single-quoted identifiers
+                                id_parts.push(Ident::with_quote('\'', s))
+                            }
+                            Token::Mul => {
+                                return Ok(WildcardExpr::QualifiedWildcard(ObjectName(id_parts)));
+                            }
+                            _ => {
+                                return self
+                                    .expected("an identifier or a '*' after '.'", next_token);
+                            }
                         }
                     }
                 }
@@ -825,6 +837,9 @@ impl<'a> Parser<'a> {
                             let next_token = self.next_token();
                             match next_token.token {
                                 Token::Word(w) => id_parts.push(w.to_ident()),
+                                Token::SingleQuotedString(s) => {
+                                    id_parts.push(Ident::with_quote('\'', s))
+                                }
                                 _ => {
                                     return self
                                         .expected("an identifier or a '*' after '.'", next_token);

tests/sqlparser_sqlite.rs

@@ -290,6 +290,12 @@ fn parse_create_table_with_strict() {
     }
 }
 
+#[test]
+fn parse_single_quoted_identified() {
+    sqlite().verified_only_select("SELECT 't'.*, t.'x' FROM 't'");
+    // TODO: add support for select 't'.x
+}
+
 #[test]
 fn parse_attach_database() {
     let sql = "ATTACH DATABASE 'test.db' AS test";