feat(planner): suggest function name on typo (#10759)

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

Author: andylokandy

Cargo.lock

@@ -43,14 +43,43 @@ use crate::Expr;
 use crate::FunctionDomain;
 use crate::Scalar;
 
+pub type AutoCastRules<'a> = &'a [(DataType, DataType)];
+/// A function to build function depending on the const parameters and the type of arguments (before coercion).
+///
+/// The first argument is the const parameters and the second argument is the types of arguments.
+pub type FunctionFactory =
+    Box<dyn Fn(&[usize], &[DataType]) -> Option<Arc<Function>> + Send + Sync + 'static>;
+
+pub struct Function {
+    pub signature: FunctionSignature,
+    pub eval: FunctionEval,
+}
+
 #[derive(Debug, Clone)]
 pub struct FunctionSignature {
     pub name: String,
     pub args_type: Vec<DataType>,
     pub return_type: DataType,
 }
 
-pub type AutoCastRules<'a> = &'a [(DataType, DataType)];
+#[derive(EnumAsInner)]
+#[allow(clippy::type_complexity)]
+pub enum FunctionEval {
+    /// Scalar function that returns a single value.
+    Scalar {
+        /// Given the domains of the arguments, return the domain of the output value.
+        calc_domain: Box<dyn Fn(&[Domain]) -> FunctionDomain<AnyType> + Send + Sync>,
+        /// Given a set of arguments, return a single value.
+        /// The result must be in the same length as the input arguments if its a column.
+        eval: Box<dyn Fn(&[ValueRef<AnyType>], &mut EvalContext) -> Value<AnyType> + Send + Sync>,
+    },
+    /// Set returning function that returns a series of values.
+    SRF {
+        /// Given a set of arguments, return a series of chunks of result and the repeat time of each chunk.
+        eval:
+            Box<dyn Fn(&[ValueRef<AnyType>], usize) -> Vec<(Value<AnyType>, usize)> + Send + Sync>,
+    },
+}
 
 #[derive(Clone, Copy, Default)]
 pub struct FunctionContext {
@@ -70,62 +99,8 @@ pub struct EvalContext<'a> {
     pub errors: Option<(MutableBitmap, String)>,
 }
 
-impl<'a> EvalContext<'a> {
-    #[inline]
-    pub fn set_error(&mut self, row: usize, error_msg: impl Into<String>) {
-        // If the row is NULL, we don't need to set error.
-        if self
-            .validity
-            .as_ref()
-            .map(|b| !b.get_bit(row))
-            .unwrap_or(false)
-        {
-            return;
-        }
-
-        match self.errors.as_mut() {
-            Some((valids, _)) => {
-                valids.set(row, false);
-            }
-            None => {
-                let mut valids = constant_bitmap(true, self.num_rows.max(1));
-                valids.set(row, false);
-                self.errors = Some((valids, error_msg.into()));
-            }
-        }
-    }
-
-    pub fn render_error(&self, span: Span, args: &[Value<AnyType>], func_name: &str) -> Result<()> {
-        match &self.errors {
-            Some((valids, error)) => {
-                let first_error_row = valids
-                    .iter()
-                    .enumerate()
-                    .filter(|(_, valid)| !valid)
-                    .take(1)
-                    .next()
-                    .unwrap()
-                    .0;
-                let args = args
-                    .iter()
-                    .map(|arg| {
-                        let arg_ref = arg.as_ref();
-                        arg_ref.index(first_error_row).unwrap().to_string()
-                    })
-                    .join(", ");
-
-                Err(ErrorCode::Internal(format!(
-                    "{error} while evaluating function `{func_name}({args})`"
-                ))
-                .set_span(span))
-            }
-            None => Ok(()),
-        }
-    }
-}
-
-/// `FunctionID` is a unique identifier for a function. It's used to construct
-/// the exactly same function from the remote execution nodes.
+/// `FunctionID` is a unique identifier for a function in the registry. It's used to
+/// construct the exactly same function in the remote execution nodes.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum FunctionID {
     Builtin {
@@ -140,22 +115,22 @@ pub enum FunctionID {
     },
 }
 
-#[derive(EnumAsInner)]
-#[allow(clippy::type_complexity)]
-pub enum FunctionEval {
-    Scalar {
-        calc_domain: Box<dyn Fn(&[Domain]) -> FunctionDomain<AnyType> + Send + Sync>,
-        eval: Box<dyn Fn(&[ValueRef<AnyType>], &mut EvalContext) -> Value<AnyType> + Send + Sync>,
-    },
-    SRF {
-        eval:
-            Box<dyn Fn(&[ValueRef<AnyType>], usize) -> Vec<(Value<AnyType>, usize)> + Send + Sync>,
-    },
-}
+#[derive(Default)]
+pub struct FunctionRegistry {
+    pub funcs: HashMap<String, Vec<(Arc<Function>, usize)>>,
+    pub factories: HashMap<String, Vec<(FunctionFactory, usize)>>,
 
-pub struct Function {
-    pub signature: FunctionSignature,
-    pub eval: FunctionEval,
+    /// Aliases map from alias function name to original function name.
+    pub aliases: HashMap<String, String>,
+
+    /// Default cast rules for all functions.
+    pub default_cast_rules: Vec<(DataType, DataType)>,
+    /// Cast rules for specific functions, excluding the default cast rules.
+    pub additional_cast_rules: HashMap<String, Vec<(DataType, DataType)>>,
+    /// The auto rules that should use TRY_CAST instead of CAST.
+    pub auto_try_cast_rules: Vec<(DataType, DataType)>,
+
+    pub properties: HashMap<String, FunctionProperty>,
 }
 
 impl Function {
@@ -180,30 +155,6 @@ impl Function {
     }
 }
 
-/// A function to build function depending on the const parameters and the type of arguments (before coercion).
-///
-/// The first argument is the const parameters and the second argument is the types of arguments.
-pub type FunctionFactory =
-    Box<dyn Fn(&[usize], &[DataType]) -> Option<Arc<Function>> + Send + Sync + 'static>;
-
-#[derive(Default)]
-pub struct FunctionRegistry {
-    pub funcs: HashMap<String, Vec<(Arc<Function>, usize)>>,
-    pub factories: HashMap<String, Vec<(FunctionFactory, usize)>>,
-
-    /// Aliases map from alias function name to original function name.
-    pub aliases: HashMap<String, String>,
-
-    /// Default cast rules for all functions.
-    pub default_cast_rules: Vec<(DataType, DataType)>,
-    /// Cast rules for specific functions, excluding the default cast rules.
-    pub additional_cast_rules: HashMap<String, Vec<(DataType, DataType)>>,
-    /// The auto rules that should use TRY_CAST instead of CAST.
-    pub auto_try_cast_rules: Vec<(DataType, DataType)>,
-
-    pub properties: HashMap<String, FunctionProperty>,
-}
-
 impl FunctionRegistry {
     pub fn empty() -> Self {
         Self::default()
@@ -376,6 +327,17 @@ impl FunctionRegistry {
             + self.factories.get(name).map(|f| f.len()).unwrap_or(0)
     }
 
+    pub fn all_function_names(&self) -> Vec<String> {
+        self.aliases
+            .keys()
+            .chain(self.funcs.keys())
+            .chain(self.factories.keys())
+            .map(|s| s.to_string())
+            .sorted()
+            .dedup()
+            .collect()
+    }
+
     pub fn check_ambiguity(&self) {
         for (name, funcs) in &self.funcs {
             let auto_cast_rules = self.get_auto_cast_rules(name);
@@ -437,6 +399,60 @@ impl FunctionID {
     }
 }
 
+impl<'a> EvalContext<'a> {
+    #[inline]
+    pub fn set_error(&mut self, row: usize, error_msg: impl Into<String>) {
+        // If the row is NULL, we don't need to set error.
+        if self
+            .validity
+            .as_ref()
+            .map(|b| !b.get_bit(row))
+            .unwrap_or(false)
+        {
+            return;
+        }
+
+        match self.errors.as_mut() {
+            Some((valids, _)) => {
+                valids.set(row, false);
+            }
+            None => {
+                let mut valids = constant_bitmap(true, self.num_rows.max(1));
+                valids.set(row, false);
+                self.errors = Some((valids, error_msg.into()));
+            }
+        }
+    }
+
+    pub fn render_error(&self, span: Span, args: &[Value<AnyType>], func_name: &str) -> Result<()> {
+        match &self.errors {
+            Some((valids, error)) => {
+                let first_error_row = valids
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, valid)| !valid)
+                    .take(1)
+                    .next()
+                    .unwrap()
+                    .0;
+                let args = args
+                    .iter()
+                    .map(|arg| {
+                        let arg_ref = arg.as_ref();
+                        arg_ref.index(first_error_row).unwrap().to_string()
+                    })
+                    .join(", ");
+
+                Err(ErrorCode::Internal(format!(
+                    "{error} while evaluating function `{func_name}({args})`"
+                ))
+                .set_span(span))
+            }
+            None => Ok(()),
+        }
+    }
+}
+
 pub fn wrap_nullable<F>(f: F) -> impl Fn(&[ValueRef<AnyType>], &mut EvalContext) -> Value<AnyType>
 where F: Fn(&[ValueRef<AnyType>], &mut EvalContext) -> Value<AnyType> {
     move |args, ctx| {

src/query/expression/src/function.rs

@@ -58,6 +58,7 @@ percent-encoding = "2"
 regex = "1.6.0"
 roaring = "0.10.1"
 serde = { workspace = true }
+simsearch = "0.2"
 time = "0.3.14"
 tracing = "0.1.36"
 url = { version = "2.3" }