Merge pull request #66 from nickolay/pr/ms-identifiers-aliases

Support for MSSQL identifier and alias parsing rules

examples/cli.rs

@@ -6,16 +6,26 @@ use simple_logger;
 /// Run with `cargo run --example cli`
 use std::fs;
 
-use sqlparser::dialect::GenericSqlDialect;
+use sqlparser::dialect::*;
 use sqlparser::sqlparser::Parser;
 
 fn main() {
     simple_logger::init().unwrap();
 
-    let filename = std::env::args()
-        .nth(1)
-        .expect("No arguments provided!\n\nUsage: cargo run --example cli FILENAME.sql");
+    let filename = std::env::args().nth(1).expect(
+        "No arguments provided!\n\n\
+         Usage: cargo run --example cli FILENAME.sql [--dialectname]",
+    );
 
+    let dialect: Box<dyn Dialect> = match std::env::args().nth(2).unwrap_or_default().as_ref() {
+        "--ansi" => Box::new(AnsiSqlDialect {}),
+        "--postgres" => Box::new(PostgreSqlDialect {}),
+        "--ms" => Box::new(MsSqlDialect {}),
+        "--generic" | "" => Box::new(GenericSqlDialect {}),
+        s => panic!("Unexpected parameter: {}", s),
+    };
+
+    println!("Parsing from file '{}' using {:?}", &filename, dialect);
     let contents = fs::read_to_string(&filename)
         .unwrap_or_else(|_| panic!("Unable to read the file {}", &filename));
     let without_bom = if contents.chars().nth(0).unwrap() as u64 != 0xfeff {
@@ -25,8 +35,7 @@ fn main() {
         chars.next();
         chars.as_str()
     };
-    println!("Input:\n'{}'", &without_bom);
-    let parse_result = Parser::parse_sql(&GenericSqlDialect {}, without_bom.to_owned());
+    let parse_result = Parser::parse_sql(&*dialect, without_bom.to_owned());
     match parse_result {
         Ok(statements) => {
             println!(

src/dialect/mssql.rs

@@ -4,6 +4,10 @@ use crate::dialect::Dialect;
 pub struct MsSqlDialect {}
 
 impl Dialect for MsSqlDialect {
+    fn is_delimited_identifier_start(&self, ch: char) -> bool {
+        ch == '"' || ch == '['
+    }
+
     fn is_identifier_start(&self, ch: char) -> bool {
         // See https://docs.microsoft.com/en-us/sql/relational-databases/databases/database-identifiers?view=sql-server-2017#rules-for-regular-identifiers
         // We don't support non-latin "letters" currently.

src/sqlparser.rs

@@ -1167,15 +1167,18 @@ impl Parser {
             {
                 Ok(Some(w.as_sql_ident()))
             }
-            ref not_an_ident if after_as => parser_err!(format!(
-                "Expected an identifier after AS, got {:?}",
-                not_an_ident
-            )),
-            Some(_not_an_ident) => {
-                self.prev_token();
+            // MSSQL supports single-quoted strings as aliases for columns
+            // We accept them as table aliases too, although MSSQL does not.
+            Some(Token::SingleQuotedString(ref s)) => Ok(Some(format!("'{}'", s))),
+            not_an_ident => {
+                if after_as {
+                    return self.expected("an identifier after AS", not_an_ident);
+                }
+                if not_an_ident.is_some() {
+                    self.prev_token();
+                }
                 Ok(None) // no alias found
             }
-            None => Ok(None),
         }
     }
 

tests/sqlparser_common.rs

@@ -212,6 +212,21 @@ fn parse_column_aliases() {
     one_statement_parses_to("SELECT a.col + 1 newname FROM foo AS a", &sql);
 }
 
+#[test]
+fn test_eof_after_as() {
+    let res = parse_sql_statements("SELECT foo AS");
+    assert_eq!(
+        ParserError::ParserError("Expected an identifier after AS, found: EOF".to_string()),
+        res.unwrap_err()
+    );
+
+    let res = parse_sql_statements("SELECT 1 FROM foo AS");
+    assert_eq!(
+        ParserError::ParserError("Expected an identifier after AS, found: EOF".to_string()),
+        res.unwrap_err()
+    );
+}
+
 #[test]
 fn parse_select_count_wildcard() {
     let sql = "SELECT COUNT(*) FROM customer";

tests/sqlparser_mssql.rs

@@ -27,7 +27,19 @@ fn parse_mssql_identifiers() {
     };
 }
 
-#[allow(dead_code)]
+#[test]
+fn parse_mssql_single_quoted_aliases() {
+    let _ = ms_and_generic().one_statement_parses_to("SELECT foo 'alias'", "SELECT foo AS 'alias'");
+}
+
+#[test]
+fn parse_mssql_delimited_identifiers() {
+    let _ = ms().one_statement_parses_to(
+        "SELECT [a.b!] [FROM] FROM foo [WHERE]",
+        "SELECT [a.b!] AS [FROM] FROM foo AS [WHERE]",
+    );
+}
+
 fn ms() -> TestedDialects {
     TestedDialects {
         dialects: vec![Box::new(MsSqlDialect {})],