rs/pg: AT TIME ZONE

Author: donhcd

src/ast/mod.rs

@@ -199,7 +199,14 @@ pub enum Expr {
         right: Box<Expr>,
     },
     /// Unary operation e.g. `NOT foo`
-    UnaryOp { op: UnaryOperator, expr: Box<Expr> },
+    UnaryOp {
+        op: UnaryOperator,
+        expr: Box<Expr>,
+    },
+    AtTimeZone {
+        expr: Box<Expr>,
+        tz: String,
+    },
     /// CAST an expression to a different data type e.g. `CAST(foo AS VARCHAR(123))`
     Cast {
         /// try_cast is a snowflake feature
@@ -229,7 +236,10 @@ pub enum Expr {
     /// A constant of form `<data_type> 'value'`.
     /// This can represent ANSI SQL `DATE`, `TIME`, and `TIMESTAMP` literals (such as `DATE '2020-01-01'`),
     /// as well as constants of other types (a non-standard PostgreSQL extension).
-    TypedString { data_type: DataType, value: String },
+    TypedString {
+        data_type: DataType,
+        value: String,
+    },
     /// Scalar function call e.g. `LEFT(foo, 5)`
     Function(Function),
     /// `CASE [<operand>] WHEN <condition> THEN <result> ... [ELSE <result>] END`
@@ -326,6 +336,8 @@ impl fmt::Display for Expr {
                     write!(f, "{} {}", op, expr)
                 }
             }
+            // rs/pg: https://docs.aws.amazon.com/redshift/latest/dg/r_AT_TIME_ZONE.html
+            Expr::AtTimeZone { expr, tz } => write!(f, "{} AT TIME ZONE '{}'", expr, tz),
             Expr::Cast {
                 try_cast,
                 expr,

src/parser.rs

@@ -817,6 +817,16 @@ impl<'a> Parser<'a> {
             ))
         } else if let Token::Word(w) = &tok {
             match w.keyword {
+                Keyword::AT if self.parse_keywords(&[Keyword::TIME, Keyword::ZONE]) => {
+                    let tz = self.parse_literal_string()?;
+                    Ok((
+                        Expr::AtTimeZone {
+                            expr: Box::new(expr),
+                            tz,
+                        },
+                        true,
+                    ))
+                }
                 Keyword::IS => {
                     if self.parse_keyword(Keyword::NULL) {
                         Ok((Expr::IsNull(Box::new(expr)), true))
@@ -969,6 +979,7 @@ impl<'a> Parser<'a> {
                 _ => Ok(0),
             },
             Token::Word(w) if w.keyword == Keyword::IS => Ok(17),
+            Token::Word(w) if w.keyword == Keyword::AT => Ok(Self::BETWEEN_PREC),
             Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),
             Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
             Token::Word(w)