WIP: parse true and false as identifiers in mssql

fixes apache#1508

Author: lovasoa

src/dialect/mod.rs

@@ -606,6 +606,12 @@ pub trait Dialect: Debug + Any {
     fn supports_top_before_distinct(&self) -> bool {
         false
     }
+
+    /// Returns true if the dialect supports boolean literals (`true` and `false`).
+    /// For example, in MSSQL these are treated as identifiers rather than boolean literals.
+    fn supports_boolean_literals(&self) -> bool {
+        true
+    }
 }
 
 /// This represents the operators for which precedence must be defined

src/dialect/mssql.rs

@@ -57,4 +57,9 @@ impl Dialect for MsSqlDialect {
     fn supports_try_convert(&self) -> bool {
         true
     }
+
+    /// In MSSQL, there is no boolean type, and `true` and `false` are valid column names
+    fn supports_boolean_literals(&self) -> bool {
+        false
+    }
 }

src/parser/mod.rs

@@ -1014,7 +1014,11 @@ impl<'a> Parser<'a> {
         let next_token = self.next_token();
         let expr = match next_token.token {
             Token::Word(w) => match w.keyword {
-                Keyword::TRUE | Keyword::FALSE | Keyword::NULL => {
+                Keyword::TRUE | Keyword::FALSE if self.dialect.supports_boolean_literals() => {
+                    self.prev_token();
+                    Ok(Expr::Value(self.parse_value()?))
+                }
+                Keyword::NULL => {
                     self.prev_token();
                     Ok(Expr::Value(self.parse_value()?))
                 }
@@ -7571,8 +7575,12 @@ impl<'a> Parser<'a> {
         let location = next_token.location;
         match next_token.token {
             Token::Word(w) => match w.keyword {
-                Keyword::TRUE => Ok(Value::Boolean(true)),
-                Keyword::FALSE => Ok(Value::Boolean(false)),
+                Keyword::TRUE if self.dialect.supports_boolean_literals() => {
+                    Ok(Value::Boolean(true))
+                }
+                Keyword::FALSE if self.dialect.supports_boolean_literals() => {
+                    Ok(Value::Boolean(false))
+                }
                 Keyword::NULL => Ok(Value::Null),
                 Keyword::NoKeyword if w.quote_style.is_some() => match w.quote_style {
                     Some('"') => Ok(Value::DoubleQuotedString(w.value)),

tests/sqlparser_common.rs

@@ -7321,15 +7321,18 @@ fn lateral_derived() {
         let lateral_str = if lateral_in { "LATERAL " } else { "" };
         let sql = format!(
             "SELECT * FROM customer LEFT JOIN {lateral_str}\
-             (SELECT * FROM order WHERE order.customer = customer.id LIMIT 3) AS order ON true"
+             (SELECT * FROM orders WHERE orders.customer = customer.id LIMIT 3) AS orders ON 1"
         );
         let select = verified_only_select(&sql);
         let from = only(select.from);
         assert_eq!(from.joins.len(), 1);
         let join = &from.joins[0];
         assert_eq!(
             join.join_operator,
-            JoinOperator::LeftOuter(JoinConstraint::On(Expr::Value(Value::Boolean(true))))
+            JoinOperator::LeftOuter(JoinConstraint::On(Expr::Value(Value::Number(
+                "1".to_string(),
+                false
+            ))))
         );
         if let TableFactor::Derived {
             lateral,
@@ -7338,10 +7341,10 @@ fn lateral_derived() {
         } = join.relation
         {
             assert_eq!(lateral_in, lateral);
-            assert_eq!(Ident::new("order"), alias.name);
+            assert_eq!(Ident::new("orders"), alias.name);
             assert_eq!(
                 subquery.to_string(),
-                "SELECT * FROM order WHERE order.customer = customer.id LIMIT 3"
+                "SELECT * FROM orders WHERE orders.customer = customer.id LIMIT 3"
             );
         } else {
             unreachable!()

tests/sqlparser_mssql.rs

@@ -1031,6 +1031,18 @@ fn parse_create_table_with_identity_column() {
     }
 }
 
+#[test]
+fn parse_true_false_as_identifiers() {
+    assert_eq!(
+        ms().verified_expr("true"),
+        Expr::Identifier(Ident::new("true"))
+    );
+    assert_eq!(
+        ms().verified_expr("false"),
+        Expr::Identifier(Ident::new("false"))
+    );
+}
+
 fn ms() -> TestedDialects {
     TestedDialects::new(vec![Box::new(MsSqlDialect {})])
 }