adding support for scale in CEIL and FLOOR functions

Author: seve-martinez

src/ast/mod.rs

@@ -477,6 +477,17 @@ pub enum CastKind {
     DoubleColon,
 }
 
+/// The syntax used in a CEIL or FLOOR expression.
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum CeilFloorKind {
+    /// `CEIL( <expr> TO <DateTimeField>)`
+    DateTimeField(DateTimeField),
+    /// `CEIL( <expr> [, <scale>])` 
+    Scale(Value),
+}
+
 /// An SQL expression of any type.
 ///
 /// The parser does not distinguish between expressions of different types
@@ -649,16 +660,22 @@ pub enum Expr {
     /// ```sql
     /// CEIL(<expr> [TO DateTimeField])
     /// ```
+    /// ```sql
+    /// CEIL( <input_expr> [, <scale_expr> ] )
+    /// ```
     Ceil {
         expr: Box<Expr>,
-        field: DateTimeField,
+        field: CeilFloorKind,
     },
     /// ```sql
     /// FLOOR(<expr> [TO DateTimeField])
     /// ```
+    /// ```sql
+    /// FLOOR( <input_expr> [, <scale_expr> ] )
+    /// 
     Floor {
         expr: Box<Expr>,
-        field: DateTimeField,
+        field: CeilFloorKind,
     },
     /// ```sql
     /// POSITION(<expr> in <expr>)
@@ -1199,17 +1216,17 @@ impl fmt::Display for Expr {
             },
             Expr::Extract { field, expr } => write!(f, "EXTRACT({field} FROM {expr})"),
             Expr::Ceil { expr, field } => {
-                if field == &DateTimeField::NoDateTime {
-                    write!(f, "CEIL({expr})")
-                } else {
-                    write!(f, "CEIL({expr} TO {field})")
+                match field {
+                    CeilFloorKind::DateTimeField(DateTimeField::NoDateTime) => write!(f, "CEIL({expr})"),
+                    CeilFloorKind::DateTimeField(dt_field) => write!(f, "CEIL({expr} TO {dt_field})"),
+                    CeilFloorKind::Scale(s) => write!(f, "CEIL({expr}, {s})"),
                 }
             }
             Expr::Floor { expr, field } => {
-                if field == &DateTimeField::NoDateTime {
-                    write!(f, "FLOOR({expr})")
-                } else {
-                    write!(f, "FLOOR({expr} TO {field})")
+                match field {
+                    CeilFloorKind::DateTimeField(DateTimeField::NoDateTime) => write!(f, "FLOOR({expr})"),
+                    CeilFloorKind::DateTimeField(dt_field) => write!(f, "FLOOR({expr} TO {dt_field})"),
+                    CeilFloorKind::Scale(s) => write!(f, "FLOOR({expr}, {s})"),
                 }
             }
             Expr::Position { expr, r#in } => write!(f, "POSITION({expr} IN {in})"),

src/parser/mod.rs

@@ -1695,12 +1695,16 @@ impl<'a> Parser<'a> {
         self.expect_token(&Token::LParen)?;
         let expr = self.parse_expr()?;
         // Parse `CEIL/FLOOR(expr)`
-        let mut field = DateTimeField::NoDateTime;
-        let keyword_to = self.parse_keyword(Keyword::TO);
-        if keyword_to {
+        let field = if self.parse_keyword(Keyword::TO) {
             // Parse `CEIL/FLOOR(expr TO DateTimeField)`
-            field = self.parse_date_time_field()?;
-        }
+            CeilFloorKind::DateTimeField(self.parse_date_time_field()?)
+        } else if self.consume_token(&Token::Comma) {
+            // Parse `CEIL/FLOOR(expr, scale)`
+            match self.parse_value()? {
+                Value::Number(n, s) => CeilFloorKind::Scale(Value::Number(n, s)),
+                _ => return Err(ParserError::ParserError("Scale field can only be of number type".to_string())),
+            }
+        } else { CeilFloorKind::DateTimeField(DateTimeField::NoDateTime) };
         self.expect_token(&Token::RParen)?;
         if is_ceil {
             Ok(Expr::Ceil {

tests/sqlparser_common.rs

@@ -2493,14 +2493,52 @@ fn parse_floor_number() {
     verified_stmt("SELECT FLOOR(float_column) FROM my_table");
 }
 
+#[test]
+fn parse_ceil_number_scale() {
+    verified_stmt("SELECT CEIL(1.5, 1)");
+    verified_stmt("SELECT CEIL(float_column, 3) FROM my_table");
+}
+
+#[test]
+fn parse_floor_number_scale() {
+    verified_stmt("SELECT FLOOR(1.5, 1)");
+    verified_stmt("SELECT FLOOR(float_column, 3) FROM my_table");
+}
+
+#[test]
+fn parse_ceil_scale() {
+    let sql = "SELECT CEIL(d, 2)";
+    let select = verified_only_select(sql);
+    assert_eq!(
+        &Expr::Ceil {
+            expr: Box::new(Expr::Identifier(Ident::new("d"))),
+            field: CeilFloorKind::Scale(Value::Number(2.to_string(), false)),
+        },
+        expr_from_projection(only(&select.projection)),
+    );
+}
+
+#[test]
+fn parse_floor_scale() {
+    let sql = "SELECT FLOOR(d, 2)";
+    let select = verified_only_select(sql);
+    assert_eq!(
+        &Expr::Floor {
+            expr: Box::new(Expr::Identifier(Ident::new("d"))),
+            field: CeilFloorKind::Scale(Value::Number(2.to_string(), false)),
+        },
+        expr_from_projection(only(&select.projection)),
+    );
+}
+
 #[test]
 fn parse_ceil_datetime() {
     let sql = "SELECT CEIL(d TO DAY)";
     let select = verified_only_select(sql);
     assert_eq!(
         &Expr::Ceil {
             expr: Box::new(Expr::Identifier(Ident::new("d"))),
-            field: DateTimeField::Day,
+            field: CeilFloorKind::DateTimeField(DateTimeField::Day),
         },
         expr_from_projection(only(&select.projection)),
     );
@@ -2527,7 +2565,7 @@ fn parse_floor_datetime() {
     assert_eq!(
         &Expr::Floor {
             expr: Box::new(Expr::Identifier(Ident::new("d"))),
-            field: DateTimeField::Day,
+            field: CeilFloorKind::DateTimeField(DateTimeField::Day),
         },
         expr_from_projection(only(&select.projection)),
     );