rewrite nvl function

datafusion/functions/src/core/mod.rs

@@ -18,17 +18,14 @@
 //! "core" DataFusion functions
 
 mod nullif;
-mod nvl;
 mod nvl2;
 
 // create UDFs
 make_udf_function!(nullif::NullIfFunc, NULLIF, nullif);
-make_udf_function!(nvl::NVLFunc, NVL, nvl);
 make_udf_function!(nvl2::NVL2Func, NVL2, nvl2);
 
 // Export the functions out of this package, both as expr_fn as well as a list of functions
 export_functions!(
     (nullif, arg_1 arg_2, "returns NULL if value1 equals value2; otherwise it returns value1. This can be used to perform the inverse operation of the COALESCE expression."),
-    (nvl, arg_1 arg_2, "returns value2 if value1 is NULL; otherwise it returns value1"),
     (nvl2, arg_1 arg_2 arg_3, "Returns value2 if value1 is not NULL; otherwise, it returns value3.")
 );

datafusion/sql/src/expr/function.rs

@@ -70,6 +70,13 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
             crate::utils::normalize_ident(name.0[0].clone())
         };
 
+        if Self::all_suger_function().contains(&name.as_str()) {
+            if let Some(expr) =
+                self.try_rewrite_suger_function(&name, &args, schema, planner_context)?
+            {
+                return Ok(expr);
+            }
+        }
         // user-defined function (UDF) should have precedence in case it has the same name as a scalar built-in function
         if let Some(fm) = self.context_provider.get_function_meta(&name) {
             let args = self.function_args_to_expr(args, schema, planner_context)?;
@@ -311,4 +318,33 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
             }
         }
     }
+
+    fn all_suger_function() -> &'static [&'static str] {
+        &["nvl", "ifnull"]
+    }
+
+    fn try_rewrite_suger_function(
+        &self,
+        name: &str,
+        args: &[FunctionArg],
+        schema: &DFSchema,
+        planner_context: &mut PlannerContext,
+    ) -> Result<Option<Expr>> {
+        match (name, args) {
+            // rewirte nvl function to nvl2 function
+            ("nvl" | "ifnull", [left, right]) => {
+                if let Some(fm) = self.context_provider.get_function_meta("nvl2") {
+                    let new_args = vec![left.clone(), left.clone(), right.clone()];
+                    let args =
+                        self.function_args_to_expr(new_args, schema, planner_context)?;
+                    Ok(Some(Expr::ScalarFunction(ScalarFunction::new_udf(
+                        fm, args,
+                    ))))
+                } else {
+                    Ok(None)
+                }
+            }
+            (_, _) => Ok(None),
+        }
+    }
 }