Merge pull request #671 from IgnisDa/master

Add SQL round function

src/backend/query_builder.rs

@@ -659,6 +659,7 @@ pub trait QueryBuilder: QuotedBuilder + EscapeBuilder + TableRefBuilder {
                     Function::BitOr => "BIT_OR",
                     Function::Custom(_) => "",
                     Function::Random => self.random_function(),
+                    Function::Round => "ROUND",
                     #[cfg(feature = "backend-postgres")]
                     Function::PgFunction(_) => unimplemented!(),
                 }

src/func.rs

@@ -24,6 +24,7 @@ pub enum Function {
     BitAnd,
     BitOr,
     Random,
+    Round,
     #[cfg(feature = "backend-postgres")]
     PgFunction(PgFunction),
 }
@@ -579,6 +580,70 @@ impl Func {
         FunctionCall::new(Function::BitOr).arg(expr)
     }
 
+    /// Call `ROUND` function.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sea_query::tests_cfg::Character::Character;
+    /// use sea_query::{tests_cfg::*, *};
+    ///
+    /// let query = Query::select().expr(Func::round(5.654)).to_owned();
+    ///
+    /// assert_eq!(query.to_string(MysqlQueryBuilder), r#"SELECT ROUND(5.654)"#);
+    ///
+    /// assert_eq!(
+    ///     query.to_string(PostgresQueryBuilder),
+    ///     r#"SELECT ROUND(5.654)"#
+    /// );
+    ///
+    /// assert_eq!(
+    ///     query.to_string(SqliteQueryBuilder),
+    ///     r#"SELECT ROUND(5.654)"#
+    /// );
+    /// ```
+    pub fn round<A>(expr: A) -> FunctionCall
+    where
+        A: Into<SimpleExpr>,
+    {
+        FunctionCall::new(Function::Round).arg(expr)
+    }
+
+    /// Call `ROUND` function with the precision.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use sea_query::tests_cfg::Character::Character;
+    /// use sea_query::{tests_cfg::*, *};
+    ///
+    /// let query = Query::select()
+    ///     .expr(Func::round_with_precision(5.654, 2))
+    ///     .to_owned();
+    ///
+    /// assert_eq!(
+    ///     query.to_string(MysqlQueryBuilder),
+    ///     r#"SELECT ROUND(5.654, 2)"#
+    /// );
+    ///
+    /// assert_eq!(
+    ///     query.to_string(PostgresQueryBuilder),
+    ///     r#"SELECT ROUND(5.654, 2)"#
+    /// );
+    ///
+    /// assert_eq!(
+    ///     query.to_string(SqliteQueryBuilder),
+    ///     r#"SELECT ROUND(5.654, 2)"#
+    /// );
+    /// ```
+    pub fn round_with_precision<A, B>(a: A, b: B) -> FunctionCall
+    where
+        A: Into<SimpleExpr>,
+        B: Into<SimpleExpr>,
+    {
+        FunctionCall::new(Function::Round).args([a.into(), b.into()])
+    }
+
     /// Call `RANDOM` function.
     ///
     /// # Examples