Check disjunctions for pushing down to source

Author: carlosdelest

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/fulltext/FullTextFunction.java

@@ -22,14 +22,12 @@
 import org.elasticsearch.xpack.esql.core.expression.function.Function;
 import org.elasticsearch.xpack.esql.core.expression.predicate.logical.BinaryLogic;
 import org.elasticsearch.xpack.esql.core.expression.predicate.logical.Not;
-import org.elasticsearch.xpack.esql.core.expression.predicate.logical.Or;
 import org.elasticsearch.xpack.esql.core.planner.ExpressionTranslator;
 import org.elasticsearch.xpack.esql.core.planner.TranslatorHandler;
 import org.elasticsearch.xpack.esql.core.querydsl.query.Query;
 import org.elasticsearch.xpack.esql.core.querydsl.query.TranslationAwareExpressionQuery;
 import org.elasticsearch.xpack.esql.core.tree.Source;
 import org.elasticsearch.xpack.esql.core.type.DataType;
-import org.elasticsearch.xpack.esql.core.util.Holder;
 import org.elasticsearch.xpack.esql.evaluator.mapper.EvaluatorMapper;
 import org.elasticsearch.xpack.esql.plan.logical.Aggregate;
 import org.elasticsearch.xpack.esql.plan.logical.EsRelation;
@@ -233,82 +231,6 @@ private static void checkFullTextQueryFunctions(LogicalPlan plan, Failures failu
         }
     }
 
-    /**
-     * Checks whether a condition contains a disjunction with a full text search.
-     * If it does, check that every element of the disjunction is a full text search or combinations (AND, OR, NOT) of them.
-     * If not, add a failure to the failures collection.
-     *
-     * @param condition        condition to check for disjunctions of full text searches
-     * @param typeNameProvider provider for the type name to add in the failure message
-     * @param failures         failures collection to add to
-     */
-    private static void checkFullTextSearchDisjunctions(
-        Expression condition,
-        java.util.function.Function<FullTextFunction, String> typeNameProvider,
-        Failures failures
-    ) {
-        Holder<Boolean> isInvalid = new Holder<>(false);
-        condition.forEachDown(Or.class, or -> {
-            if (isInvalid.get()) {
-                // Exit early if we already have a failures
-                return;
-            }
-            boolean hasFullText = or.anyMatch(FullTextFunction.class::isInstance);
-            if (hasFullText) {
-                boolean hasOnlyFullText = onlyFullTextFunctionsInExpression(or);
-                if (hasOnlyFullText == false) {
-                    isInvalid.set(true);
-                    failures.add(
-                        fail(
-                            or,
-                            "Invalid condition [{}]. Full text functions can be used in an OR condition, "
-                                + "but only if just full text functions are used in the OR condition",
-                            or.sourceText()
-                        )
-                    );
-                }
-            }
-        });
-    }
-
-    /**
-     * Checks whether an expression contains just full text functions or negations (NOT) and combinations (AND, OR) of full text functions
-     *
-     * @param expression expression to check
-     * @return true if all children are full text functions or negations of full text functions, false otherwise
-     */
-    private static boolean onlyFullTextFunctionsInExpression(Expression expression) {
-        if (expression instanceof FullTextFunction) {
-            return true;
-        } else if (expression instanceof Not) {
-            return onlyFullTextFunctionsInExpression(expression.children().get(0));
-        } else if (expression instanceof BinaryLogic binaryLogic) {
-            return onlyFullTextFunctionsInExpression(binaryLogic.left()) && onlyFullTextFunctionsInExpression(binaryLogic.right());
-        }
-
-        return false;
-    }
-
-    /**
-     * Checks whether an expression contains a full text function as part of it
-     *
-     * @param expression expression to check
-     * @return true if the expression or any of its children is a full text function, false otherwise
-     */
-    private static boolean anyFullTextFunctionsInExpression(Expression expression) {
-        if (expression instanceof FullTextFunction) {
-            return true;
-        }
-
-        for (Expression child : expression.children()) {
-            if (anyFullTextFunctionsInExpression(child)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
     /**
      * Checks all commands that exist before a specific type satisfy conditions.
      *
@@ -387,7 +309,6 @@ private static FullTextFunction forEachFullTextFunctionParent(Expression conditi
         return null;
     }
 
-
     @Override
     public EvalOperator.ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
         List<EsPhysicalOperationProviders.ShardContext> shardContexts = toEvaluator.shardContexts();

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/physical/local/PushFiltersToSource.java

@@ -8,6 +8,7 @@
 package org.elasticsearch.xpack.esql.optimizer.rules.physical.local;
 
 import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.xpack.esql.common.Failures;
 import org.elasticsearch.xpack.esql.core.expression.Alias;
 import org.elasticsearch.xpack.esql.core.expression.Attribute;
 import org.elasticsearch.xpack.esql.core.expression.AttributeMap;
@@ -21,6 +22,7 @@
 import org.elasticsearch.xpack.esql.core.expression.predicate.Range;
 import org.elasticsearch.xpack.esql.core.expression.predicate.logical.BinaryLogic;
 import org.elasticsearch.xpack.esql.core.expression.predicate.logical.Not;
+import org.elasticsearch.xpack.esql.core.expression.predicate.logical.Or;
 import org.elasticsearch.xpack.esql.core.expression.predicate.nulls.IsNotNull;
 import org.elasticsearch.xpack.esql.core.expression.predicate.nulls.IsNull;
 import org.elasticsearch.xpack.esql.core.expression.predicate.operator.comparison.BinaryComparison;
@@ -29,6 +31,7 @@
 import org.elasticsearch.xpack.esql.core.querydsl.query.Query;
 import org.elasticsearch.xpack.esql.core.type.DataType;
 import org.elasticsearch.xpack.esql.core.util.CollectionUtils;
+import org.elasticsearch.xpack.esql.core.util.Holder;
 import org.elasticsearch.xpack.esql.core.util.Queries;
 import org.elasticsearch.xpack.esql.expression.function.fulltext.FullTextFunction;
 import org.elasticsearch.xpack.esql.expression.function.scalar.ip.CIDRMatch;
@@ -232,7 +235,9 @@ static boolean canPushToSource(Expression exp, LucenePushdownPredicates lucenePu
         } else if (exp instanceof InsensitiveBinaryComparison bc) {
             return isAttributePushable(bc.left(), bc, lucenePushdownPredicates) && bc.right().foldable();
         } else if (exp instanceof BinaryLogic bl) {
-            return canPushToSource(bl.left(), lucenePushdownPredicates) && canPushToSource(bl.right(), lucenePushdownPredicates);
+            return canPushToSource(bl.left(), lucenePushdownPredicates)
+                && canPushToSource(bl.right(), lucenePushdownPredicates)
+                && checkPushableFullTextSearchFunctions(exp);
         } else if (exp instanceof In in) {
             return isAttributePushable(in.value(), null, lucenePushdownPredicates) && Expressions.foldable(in.list());
         } else if (exp instanceof Not not) {
@@ -252,8 +257,8 @@ static boolean canPushToSource(Expression exp, LucenePushdownPredicates lucenePu
         } else if (exp instanceof SpatialRelatesFunction spatial) {
             return canPushSpatialFunctionToSource(spatial, lucenePushdownPredicates);
         } else if (exp instanceof FullTextFunction) {
-            // TODO check for disjunctions
-            return false;
+            // In isolation, full text functions are pushable to source. We check if there are no disjunctions on the binary logic check
+            return true;
         }
         return false;
     }
@@ -269,6 +274,49 @@ public static boolean canPushSpatialFunctionToSource(BinarySpatialFunction s, Lu
             || isPushableSpatialAttribute(s.right(), lucenePushdownPredicates) && s.left().foldable();
     }
 
+    /**
+     * Checks whether a condition contains a full text function that can't be pushed down to source.
+     * Full text functions can be pushed down as long as they are the only functions in the expression, or there are no disjunctions with
+     * other non-full text functions conditions.
+     *
+     * @param condition        condition to check for disjunctions of full text searches
+     */
+    private static boolean checkPushableFullTextSearchFunctions(Expression condition) {
+        Holder<Boolean> isPushable = new Holder<>(true);
+        condition.forEachDown(Or.class, or -> {
+            if (isPushable.get() == false) {
+                // Exit early if we already have a failures
+                return;
+            }
+            boolean hasFullText = or.anyMatch(FullTextFunction.class::isInstance);
+            if (hasFullText) {
+                boolean hasOnlyFullText = onlyFullTextFunctionsInExpression(or);
+                if (hasOnlyFullText == false) {
+                    isPushable.set(false);
+                }
+            }
+        });
+        return isPushable.get();
+    }
+
+    /**
+     * Checks whether an expression contains just full text functions or negations (NOT) and combinations (AND, OR) of full text functions
+     *
+     * @param expression expression to check
+     * @return true if all children are full text functions or negations of full text functions, false otherwise
+     */
+    private static boolean onlyFullTextFunctionsInExpression(Expression expression) {
+        if (expression instanceof FullTextFunction) {
+            return true;
+        } else if (expression instanceof Not) {
+            return onlyFullTextFunctionsInExpression(expression.children().get(0));
+        } else if (expression instanceof BinaryLogic binaryLogic) {
+            return onlyFullTextFunctionsInExpression(binaryLogic.left()) && onlyFullTextFunctionsInExpression(binaryLogic.right());
+        }
+
+        return false;
+    }
+
     private static boolean isPushableSpatialAttribute(Expression exp, LucenePushdownPredicates p) {
         return exp instanceof FieldAttribute fa && DataType.isSpatial(fa.dataType()) && fa.getExactInfo().hasExact() && p.isIndexed(fa);
     }