snowflake: try_cast

Author: donhcd

src/ast/mod.rs

@@ -202,6 +202,8 @@ pub enum Expr {
     UnaryOp { op: UnaryOperator, expr: Box<Expr> },
     /// CAST an expression to a different data type e.g. `CAST(foo AS VARCHAR(123))`
     Cast {
+        /// try_cast is a snowflake feature
+        try_cast: bool,
         expr: Box<Expr>,
         data_type: DataType,
     },
@@ -323,7 +325,17 @@ impl fmt::Display for Expr {
                     write!(f, "{} {}", op, expr)
                 }
             }
-            Expr::Cast { expr, data_type } => write!(f, "CAST({} AS {})", expr, data_type),
+            Expr::Cast {
+                try_cast,
+                expr,
+                data_type,
+            } => write!(
+                f,
+                "{}CAST({} AS {})",
+                if *try_cast { "TRY_" } else { "" },
+                expr,
+                data_type
+            ),
             Expr::Extract { field, expr } => write!(f, "EXTRACT({} FROM {})", field, expr),
             Expr::Collate { expr, collation } => write!(f, "{} COLLATE {}", expr, collation),
             Expr::Index { expr, index_expr } => write!(f, "{}[{}]", expr, index_expr),

src/dialect/keywords.rs

@@ -432,6 +432,7 @@ define_keywords!(
     TRIM_ARRAY,
     TRUE,
     TRUNCATE,
+    TRY_CAST,
     UESCAPE,
     UNBOUNDED,
     UNCOMMITTED,

src/parser.rs

@@ -243,7 +243,8 @@ impl<'a> Parser<'a> {
                     Ok(Expr::Value(self.parse_value()?))
                 }
                 Keyword::CASE => self.parse_case_expr(),
-                Keyword::CAST => self.parse_cast_expr(),
+                Keyword::CAST => self.parse_cast_expr(false),
+                Keyword::TRY_CAST => self.parse_cast_expr(true),
                 Keyword::EXISTS => self.parse_exists_expr(),
                 Keyword::EXTRACT => self.parse_extract_expr(),
                 Keyword::INTERVAL => self.parse_literal_interval(),
@@ -481,13 +482,14 @@ impl<'a> Parser<'a> {
     }
 
     /// Parse a SQL CAST function e.g. `CAST(expr AS FLOAT)`
-    pub fn parse_cast_expr(&mut self) -> Result<Expr, ParserError> {
+    pub fn parse_cast_expr(&mut self, try_cast: bool) -> Result<Expr, ParserError> {
         self.expect_token(&Token::LParen)?;
         let expr = self.parse_expr()?;
         self.expect_keyword(Keyword::AS)?;
         let data_type = self.parse_data_type()?;
         self.expect_token(&Token::RParen)?;
         Ok(Expr::Cast {
+            try_cast,
             expr: Box::new(expr),
             data_type,
         })
@@ -853,6 +855,7 @@ impl<'a> Parser<'a> {
     /// Parse a postgresql casting style which is in the form of `expr::datatype`
     pub fn parse_pg_cast(&mut self, expr: Expr) -> Result<Expr, ParserError> {
         Ok(Expr::Cast {
+            try_cast: false,
             expr: Box::new(expr),
             data_type: self.parse_data_type()?,
         })