support general typed string literal

This is a direct port of MaterializeInc/materialize#3146. It provides
support for e.g. Postgres syntax where any string literal may be
preceded by a type name.

Fixes #168.

Author: maxcountryman

src/ast/value.rs

@@ -30,12 +30,6 @@ pub enum Value {
     HexStringLiteral(String),
     /// Boolean value true or false
     Boolean(bool),
-    /// `DATE '...'` literals
-    Date(String),
-    /// `TIME '...'` literals
-    Time(String),
-    /// `TIMESTAMP '...'` literals
-    Timestamp(String),
     /// INTERVAL literals, roughly in the following format:
     /// `INTERVAL '<value>' <leading_field> [ (<leading_precision>) ]
     /// [ TO <last_field> [ (<fractional_seconds_precision>) ] ]`,
@@ -67,9 +61,6 @@ impl fmt::Display for Value {
             Value::NationalStringLiteral(v) => write!(f, "N'{}'", v),
             Value::HexStringLiteral(v) => write!(f, "X'{}'", v),
             Value::Boolean(v) => write!(f, "{}", v),
-            Value::Date(v) => write!(f, "DATE '{}'", escape_single_quote_string(v)),
-            Value::Time(v) => write!(f, "TIME '{}'", escape_single_quote_string(v)),
-            Value::Timestamp(v) => write!(f, "TIMESTAMP '{}'", escape_single_quote_string(v)),
             Value::Interval {
                 value,
                 leading_field: DateTimeField::Second,

src/parser.rs

@@ -34,6 +34,14 @@ macro_rules! parser_err {
     };
 }
 
+macro_rules! maybe {
+    ($e:expr) => {{
+        if let Some(v) = $e {
+            return Ok(v);
+        }
+    }};
+}
+
 #[derive(PartialEq)]
 pub enum IsOptional {
     Optional,
@@ -176,6 +184,34 @@ impl Parser {
 
     /// Parse an expression prefix
     pub fn parse_prefix(&mut self) -> Result<Expr, ParserError> {
+        // PostgreSQL allows any string literal to be prceded by a type name, indicating that the
+        // string literal represents a literal of that type. Some examples:
+        //
+        //      DATE '2020-05-20'
+        //      TIMESTAMP WITH TIME ZONE '2020-05-20 7:43:54'
+        //      BOOL 'true'
+        //
+        // The first two are standard SQL, while the latter is a PostgreSQL extension. Complicating
+        // matters is the fact that INTERVAL string literals may optionally be followed by special
+        // keywords, e.g.:
+        //
+        //      INTERVAL '7' DAY
+        //
+        // Note also that naively `SELECT date` looks like a syntax error because the `date` type
+        // name is not followed by a string literal, but in fact is a valid expression that should
+        // parse as the column name "date".
+        maybe!(self.maybe_parse(|parser| {
+            match parser.parse_data_type()? {
+                DataType::Interval => parser.parse_literal_interval(),
+                data_type => Ok(Expr::Cast {
+                    expr: Box::new(Expr::Value(Value::SingleQuotedString(
+                        parser.parse_literal_string()?,
+                    ))),
+                    data_type,
+                }),
+            }
+        }));
+
         let tok = self
             .next_token()
             .ok_or_else(|| ParserError::ParserError("Unexpected EOF".to_string()))?;
@@ -187,7 +223,6 @@ impl Parser {
                 }
                 "CASE" => self.parse_case_expr(),
                 "CAST" => self.parse_cast_expr(),
-                "DATE" => Ok(Expr::Value(Value::Date(self.parse_literal_string()?))),
                 "EXISTS" => self.parse_exists_expr(),
                 "EXTRACT" => self.parse_extract_expr(),
                 "INTERVAL" => self.parse_literal_interval(),
@@ -196,8 +231,6 @@ impl Parser {
                     op: UnaryOperator::Not,
                     expr: Box::new(self.parse_subexpr(Self::UNARY_NOT_PREC)?),
                 }),
-                "TIME" => Ok(Expr::Value(Value::Time(self.parse_literal_string()?))),
-                "TIMESTAMP" => Ok(Expr::Value(Value::Timestamp(self.parse_literal_string()?))),
                 // Here `w` is a word, check if it's a part of a multi-part
                 // identifier, a function call, or a simple identifier:
                 _ => match self.peek_token() {
@@ -912,6 +945,20 @@ impl Parser {
         Ok(values)
     }
 
+    #[must_use]
+    fn maybe_parse<T, F>(&mut self, mut f: F) -> Option<T>
+    where
+        F: FnMut(&mut Parser) -> Result<T, ParserError>,
+    {
+        let index = self.index;
+        if let Ok(t) = f(self) {
+            Some(t)
+        } else {
+            self.index = index;
+            None
+        }
+    }
+
     /// Parse either `ALL` or `DISTINCT`. Returns `true` if `DISTINCT` is parsed and results in a
     /// `ParserError` if both `ALL` and `DISTINCT` are fround.
     pub fn parse_all_or_distinct(&mut self) -> Result<bool, ParserError> {
@@ -1908,7 +1955,6 @@ impl Parser {
         }
 
         if self.consume_token(&Token::LParen) {
-            let index = self.index;
             // A left paren introduces either a derived table (i.e., a subquery)
             // or a nested join. It's nearly impossible to determine ahead of
             // time which it is... so we just try to parse both.
@@ -1925,30 +1971,20 @@ impl Parser {
             //                   | (2) starts a nested join
             //                   (1) an additional set of parens around a nested join
             //
-            match self.parse_derived_table_factor(NotLateral) {
-                // The recently consumed '(' started a derived table, and we've
-                // parsed the subquery, followed by the closing ')', and the
-                // alias of the derived table. In the example above this is
-                // case (3), and the next token would be `NATURAL`.
-                Ok(table_factor) => Ok(table_factor),
-                Err(_) => {
-                    // A parsing error from `parse_derived_table_factor` indicates that
-                    // the '(' we've recently consumed does not start a derived table
-                    // (cases 1, 2, or 4). Ignore the error and back up to where we
-                    // were before - right after the opening '('.
-                    self.index = index;
-
-                    // Inside the parentheses we expect to find a table factor
-                    // followed by some joins or another level of nesting.
-                    let table_and_joins = self.parse_table_and_joins()?;
-                    self.expect_token(&Token::RParen)?;
-                    // The SQL spec prohibits derived and bare tables from appearing
-                    // alone in parentheses. We don't enforce this as some databases
-                    // (e.g. Snowflake) allow such syntax.
 
-                    Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
-                }
-            }
+            // Check if the recently consumed '(' started a derived table, in which case we've
+            // parsed the subquery, followed by the closing ')', and the alias of the derived
+            // table. In the example above this is case (3), or another nested join (2).
+            maybe!(self.maybe_parse(|parser| parser.parse_derived_table_factor(NotLateral)));
+
+            // Inside the parentheses we expect to find a table factor
+            // followed by some joins or another level of nesting.
+            let table_and_joins = self.parse_table_and_joins()?;
+            self.expect_token(&Token::RParen)?;
+            // The SQL spec prohibits derived and bare tables from appearing
+            // alone in parentheses. We don't enforce this as some databases
+            // (e.g. Snowflake) allow such syntax.
+            Ok(TableFactor::NestedJoin(Box::new(table_and_joins)))
         } else {
             let name = self.parse_object_name()?;
             // Postgres, MSSQL: table-valued functions:

tests/sqlparser_common.rs

@@ -412,6 +412,19 @@ fn parse_null_in_select() {
     );
 }
 
+#[test]
+fn parse_select_with_date_column_name() {
+    let sql = "SELECT date";
+    let select = verified_only_select(sql);
+    assert_eq!(
+        &Expr::Identifier(Ident {
+            value: "date".into(),
+            quote_style: None
+        }),
+        expr_from_projection(only(&select.projection)),
+    );
+}
+
 #[test]
 fn parse_escaped_single_quote_string_predicate() {
     use self::BinaryOperator::*;
@@ -554,16 +567,19 @@ fn parse_not_precedence() {
     );
 
     // NOT has lower precedence than LIKE, so the following parses as NOT ('a' NOT LIKE 'b')
-    let sql = "NOT 'a' NOT LIKE 'b'";
+    let sql = "CAST('a' AS NOT) NOT LIKE 'b'";
     assert_eq!(
         verified_expr(sql),
-        Expr::UnaryOp {
-            op: UnaryOperator::Not,
-            expr: Box::new(Expr::BinaryOp {
-                left: Box::new(Expr::Value(Value::SingleQuotedString("a".into()))),
-                op: BinaryOperator::NotLike,
-                right: Box::new(Expr::Value(Value::SingleQuotedString("b".into()))),
+        Expr::BinaryOp {
+            left: Box::new(Expr::Cast {
+                expr: Box::new(Expr::Value(Value::SingleQuotedString("a".into()))),
+                data_type: DataType::Custom(ObjectName(vec![Ident {
+                    value: "NOT".into(),
+                    quote_style: None
+                }]))
             }),
+            op: BinaryOperator::NotLike,
+            right: Box::new(Expr::Value(Value::SingleQuotedString("b".into())))
         },
     );
 
@@ -1423,30 +1439,41 @@ fn parse_literal_string() {
 
 #[test]
 fn parse_literal_date() {
-    let sql = "SELECT DATE '1999-01-01'";
+    let sql = "SELECT CAST('1999-01-01' AS date)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Date("1999-01-01".into())),
+        &Expr::Cast {
+            expr: Box::new(Expr::Value(Value::SingleQuotedString("1999-01-01".into()))),
+            data_type: DataType::Date
+        },
         expr_from_projection(only(&select.projection)),
     );
 }
 
 #[test]
 fn parse_literal_time() {
-    let sql = "SELECT TIME '01:23:34'";
+    let sql = "SELECT CAST('01:23:34' AS time)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Time("01:23:34".into())),
+        &Expr::Cast {
+            expr: Box::new(Expr::Value(Value::SingleQuotedString("01:23:34".into()))),
+            data_type: DataType::Time
+        },
         expr_from_projection(only(&select.projection)),
     );
 }
 
 #[test]
 fn parse_literal_timestamp() {
-    let sql = "SELECT TIMESTAMP '1999-01-01 01:23:34'";
+    let sql = "SELECT CAST('1999-01-01 01:23:34' AS timestamp)";
     let select = verified_only_select(sql);
     assert_eq!(
-        &Expr::Value(Value::Timestamp("1999-01-01 01:23:34".into())),
+        &Expr::Cast {
+            expr: Box::new(Expr::Value(Value::SingleQuotedString(
+                "1999-01-01 01:23:34".into()
+            ))),
+            data_type: DataType::Timestamp
+        },
         expr_from_projection(only(&select.projection)),
     );
 }

tests/sqlparser_mssql.rs

@@ -41,7 +41,8 @@ fn parse_mssql_identifiers() {
 
 #[test]
 fn parse_mssql_single_quoted_aliases() {
-    let _ = ms_and_generic().one_statement_parses_to("SELECT foo 'alias'", "SELECT foo AS 'alias'");
+    let _ = ms_and_generic()
+        .one_statement_parses_to("SELECT foo 'alias'", "SELECT CAST('alias' AS foo)");
 }
 
 #[test]