-if !match_visitor.is_support_match_all {
+if match_visitor.has_match_all && !match_visitor.is_support_match_all {
     return Err(Error::ErrorCode(ErrorCodes::SearchSQLNotValid(
         "Using match_all() function in a subquery/join is not supported".to_string(),
     )));
 }

 pub fn has_match_all(expr: &Expr) -> bool {
-    let mut has_match_all = false;
+    let mut has_match_all_flag = false;
     let _ = visit_expressions(expr, |expr| {
         if let Expr::Function(func) = expr {
-            let name = func.name.to_string().to_lowercase();
-            if (name == MATCH_ALL_UDF_NAME || name == FUZZY_MATCH_ALL_UDF_NAME)
-                && let FunctionArguments::List(list) = &func.args
-                && !list.args.is_empty()
-            {
-                has_match_all = true;
-                return ControlFlow::Break(());
+            if let Some(ident) = func.name.0.last() {
+                let name_lc = ident.value.to_lowercase();
+                if (name_lc == MATCH_ALL_UDF_NAME || name_lc == FUZZY_MATCH_ALL_UDF_NAME)
+                    && matches!(&func.args, FunctionArguments::List(list) if !list.args.is_empty())
+                {
+                    has_match_all_flag = true;
+                    return ControlFlow::Break(());
+                }
             }
         }
         ControlFlow::Continue(())
     });
-    has_match_all
+    has_match_all_flag
 }

 if let sqlparser::ast::SetExpr::Select(select) = query.body.as_ref() {
-    // if from clause has more than one table, where clause should not have match_all
-    if select.from.len() > 1 && select.selection.as_ref().is_some_and(has_match_all) {
+    let where_has = select.selection.as_ref().is_some_and(has_match_all);
+    let having_has = select.having.as_ref().is_some_and(has_match_all);
+    let joins_have = select
+        .from
+        .iter()
+        .flat_map(|from| from.joins.iter())
+        .any(|j| j.condition.on().is_some_and(has_match_all));
+
+    let any_clause_has = where_has || having_has || joins_have;
+
+    // more than one table in FROM
+    if select.from.len() > 1 && any_clause_has {
         self.is_support_match_all = false;
     }
-
-    // if from clause has join, where clause should not have match_all
-    if select.from.iter().any(|from| !from.joins.is_empty())
-        && select.selection.as_ref().is_some_and(has_match_all)
-    {
+    // explicit joins
+    if select.from.iter().any(|from| !from.joins.is_empty()) && any_clause_has {
         self.is_support_match_all = false;
     }
-
-    // if from clause has a subquery, where clause should not have match_all
+    // outer WHERE/HAVING/ON with derived table in FROM
     if select
         .from
         .iter()
         .any(|from| matches!(from.relation, TableFactor::Derived { .. }))
-        && select.selection.as_ref().is_some_and(has_match_all)
+        && any_clause_has
     {
         self.is_support_match_all = false;
     }
-
-    // if query has CTE (Common Table Expression), where clause should not have match_all
-    if query.with.is_some() && select.selection.as_ref().is_some_and(has_match_all) {
+    // CTE with outer WHERE/HAVING/ON
+    if query.with.is_some() && any_clause_has {
         self.is_support_match_all = false;
     }
 }