Esql mv_contains function

x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/operator/EvalOperator.java

@@ -157,34 +157,114 @@ default boolean eagerEvalSafeInLazy() {
         long baseRamBytesUsed();
     }
 
-    public static final ExpressionEvaluator.Factory CONSTANT_NULL_FACTORY = new ExpressionEvaluator.Factory() {
+    private record ConstantNullEvaluator(DriverContext context) implements ExpressionEvaluator {
+        private static final String NAME = "ConstantNull";
+        private static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(ConstantNullEvaluator.class);
+
+        @Override
+        public Block eval(Page page) {
+            return context.blockFactory().newConstantNullBlock(page.getPositionCount());
+        }
+
         @Override
-        public ExpressionEvaluator get(DriverContext driverContext) {
-            return new ExpressionEvaluator() {
-                @Override
-                public Block eval(Page page) {
-                    return driverContext.blockFactory().newConstantNullBlock(page.getPositionCount());
-                }
-
-                @Override
-                public void close() {}
-
-                @Override
-                public String toString() {
-                    return CONSTANT_NULL_NAME;
-                }
-
-                @Override
-                public long baseRamBytesUsed() {
-                    return 0;
-                }
+        public void close() {}
+
+        @Override
+        public String toString() {
+            return NAME;
+        }
+
+        @Override
+        public long baseRamBytesUsed() {
+            return BASE_RAM_BYTES_USED;
+        }
+
+        record Factory() implements ExpressionEvaluator.Factory {
+            @Override
+            public ConstantNullEvaluator get(DriverContext context) {
+                return new ConstantNullEvaluator(context);
             };
+
+            @Override
+            public String toString() {
+                return NAME;
+            }
+        };
+    }
+
+    public static final ExpressionEvaluator.Factory CONSTANT_NULL_FACTORY = new ConstantNullEvaluator.Factory();
+
+    private record ConstantTrueEvaluator(DriverContext context) implements ExpressionEvaluator {
+        private static final String NAME = "ConstantTrue";
+        private static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(ConstantTrueEvaluator.class);
+
+        @Override
+        public Block eval(Page page) {
+            return context.blockFactory().newConstantBooleanBlockWith(true, page.getPositionCount());
         }
 
+        @Override
+        public void close() {}
+
         @Override
         public String toString() {
-            return CONSTANT_NULL_NAME;
+            return NAME;
+        }
+
+        @Override
+        public long baseRamBytesUsed() {
+            return BASE_RAM_BYTES_USED;
         }
-    };
-    private static final String CONSTANT_NULL_NAME = "ConstantNull";
+
+        record Factory() implements ExpressionEvaluator.Factory {
+            @Override
+            public ConstantTrueEvaluator get(DriverContext context) {
+                return new ConstantTrueEvaluator(context);
+            };
+
+            @Override
+            public String toString() {
+                return NAME;
+            }
+        };
+    }
+
+    public static final ExpressionEvaluator.Factory CONSTANT_TRUE_FACTORY = new ConstantTrueEvaluator.Factory();
+
+    private record ConstantFalseEvaluator(DriverContext context) implements ExpressionEvaluator {
+        private static final String NAME = "ConstantFalse";
+        private static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(ConstantFalseEvaluator.class);
+
+        @Override
+        public Block eval(Page page) {
+            return context.blockFactory().newConstantBooleanBlockWith(false, page.getPositionCount());
+        }
+
+        @Override
+        public void close() {}
+
+        @Override
+        public String toString() {
+            return NAME;
+        }
+
+        @Override
+        public long baseRamBytesUsed() {
+            return BASE_RAM_BYTES_USED;
+        }
+
+        record Factory() implements ExpressionEvaluator.Factory {
+            @Override
+            public ConstantFalseEvaluator get(DriverContext context) {
+                return new ConstantFalseEvaluator(context);
+            };
+
+            @Override
+            public String toString() {
+                return NAME;
+            }
+        };
+    }
+
+    public static final ExpressionEvaluator.Factory CONSTANT_FALSE_FACTORY = new ConstantFalseEvaluator.Factory();
 }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvContains.java

@@ -37,6 +37,7 @@
 import org.elasticsearch.xpack.esql.expression.function.FunctionAppliesToLifecycle;
 import org.elasticsearch.xpack.esql.expression.function.FunctionInfo;
 import org.elasticsearch.xpack.esql.expression.function.Param;
+import org.elasticsearch.xpack.esql.expression.predicate.nulls.IsNull;
 import org.elasticsearch.xpack.esql.planner.PlannerUtils;
 
 import java.io.IOException;
@@ -181,7 +182,7 @@ public ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
         var subsetType = PlannerUtils.toElementType(right().dataType());
 
         if (subsetType == ElementType.NULL) {
-            return new ConstantBooleanTrueEvaluator();
+            return EvalOperator.CONSTANT_TRUE_FACTORY;
         }
 
         if (supersetType != ElementType.NULL && supersetType != subsetType) {
@@ -200,18 +201,13 @@ public ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
             case DOUBLE -> new MvContainsDoubleEvaluator.Factory(source(), toEvaluator.apply(left()), toEvaluator.apply(right()));
             case INT -> new MvContainsIntEvaluator.Factory(source(), toEvaluator.apply(left()), toEvaluator.apply(right()));
             case LONG -> new MvContainsLongEvaluator.Factory(source(), toEvaluator.apply(left()), toEvaluator.apply(right()));
-            case NULL -> new MvContainsNullSupersetEvaluator.Factory(source(), toEvaluator.apply(right()));
+            case NULL -> new IsNull.IsNullEvaluatorFactory(toEvaluator.apply(right()));
             default -> throw EsqlIllegalArgumentException.illegalDataType(dataType());
         };
     }
 
     static void process(BooleanBlock.Builder builder, int position, Block subset) {
-        final var valueCount = subset.getValueCount(position);
-        final var startIndex = subset.getFirstValueIndex(position);
-        for (int valueIndex = startIndex; valueIndex < startIndex + valueCount; valueIndex++) {
-            if (subset.isNull(valueIndex)) {
-                continue;
-            }
+        if (subset.isNull(position) == false) {
             appendTo(builder, false);
             return;
         }
@@ -356,74 +352,6 @@ public String toString() {
         }
     }
 
-    /**
-     * Evaluator for when the lhs is null
-     * Like the ones below should be able to autogenerate as well when the generator is more flexible
-     */
-    public static class MvContainsNullSupersetEvaluator implements EvalOperator.ExpressionEvaluator {
-        private static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(MvContainsNullSupersetEvaluator.class);
-        private final EvalOperator.ExpressionEvaluator subsetFieldEvaluator;
-        private final DriverContext driverContext;
-
-        public MvContainsNullSupersetEvaluator(EvalOperator.ExpressionEvaluator subsetFieldEvaluator, DriverContext driverContext) {
-            this.subsetFieldEvaluator = subsetFieldEvaluator;
-            this.driverContext = driverContext;
-        }
-
-        @Override
-        public Block eval(Page page) {
-            try (Block block = subsetFieldEvaluator.eval(page)) {
-                return eval(page.getPositionCount(), block);
-            }
-        }
-
-        public BooleanBlock eval(int positionCount, Block subsetBlock) {
-            try (BooleanBlock.Builder result = driverContext.blockFactory().newBooleanBlockBuilder(positionCount)) {
-                for (int p = 0; p < positionCount; p++) {
-                    MvContains.process(result, p, subsetBlock);
-                }
-                return result.build();
-            }
-        }
-
-        @Override
-        public long baseRamBytesUsed() {
-            long baseRamBytesUsed = BASE_RAM_BYTES_USED;
-            baseRamBytesUsed += subsetFieldEvaluator.baseRamBytesUsed();
-            return baseRamBytesUsed;
-        }
-
-        @Override
-        public void close() {
-            Releasables.closeExpectNoException(subsetFieldEvaluator);
-        }
-
-        @Override
-        public String toString() {
-            return "MvContainsNullSupersetEvaluator[" + "subsetField=" + subsetFieldEvaluator + "]";
-        }
-
-        public static class Factory implements EvalOperator.ExpressionEvaluator.Factory {
-            private final Source source;
-            private final EvalOperator.ExpressionEvaluator.Factory subsetFieldEvaluator;
-
-            public Factory(Source source, EvalOperator.ExpressionEvaluator.Factory subsetField) {
-                this.source = source;
-                this.subsetFieldEvaluator = subsetField;
-            }
-
-            @Override
-            public MvContainsNullSupersetEvaluator get(DriverContext context) {
-                return new MvContainsNullSupersetEvaluator(subsetFieldEvaluator.get(context), context);
-            }
-
-            @Override
-            public String toString() {
-                return "MvContainsNullSupersetEvaluator[" + "subsetField=" + subsetFieldEvaluator + "]";
-            }
-        }
-    }
-
     /**
      *  Currently {@code EvaluatorImplementer} generates:
      *          if (allBlocksAreNulls) {

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/predicate/nulls/IsNull.java

@@ -12,7 +12,7 @@
 import org.elasticsearch.compute.data.Block;
 import org.elasticsearch.compute.data.Page;
 import org.elasticsearch.compute.operator.DriverContext;
-import org.elasticsearch.compute.operator.EvalOperator;
+import org.elasticsearch.compute.operator.EvalOperator.ExpressionEvaluator;
 import org.elasticsearch.core.Releasables;
 import org.elasticsearch.xpack.esql.capabilities.TranslationAware;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
@@ -103,7 +103,7 @@ public Object fold(FoldContext ctx) {
     }
 
     @Override
-    public EvalOperator.ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
+    public ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
         return new IsNullEvaluatorFactory(toEvaluator.apply(field()));
     }
 
@@ -138,9 +138,9 @@ public Query asQuery(LucenePushdownPredicates pushdownPredicates, TranslatorHand
         return new NotQuery(source(), new ExistsQuery(source(), handler.nameOf(field())));
     }
 
-    record IsNullEvaluatorFactory(EvalOperator.ExpressionEvaluator.Factory field) implements EvalOperator.ExpressionEvaluator.Factory {
+    public record IsNullEvaluatorFactory(ExpressionEvaluator.Factory field) implements ExpressionEvaluator.Factory {
         @Override
-        public EvalOperator.ExpressionEvaluator get(DriverContext context) {
+        public ExpressionEvaluator get(DriverContext context) {
             return new IsNullEvaluator(context, field.get(context));
         }
 
@@ -150,9 +150,7 @@ public String toString() {
         }
     }
 
-    record IsNullEvaluator(DriverContext driverContext, EvalOperator.ExpressionEvaluator field)
-        implements
-            EvalOperator.ExpressionEvaluator {
+    record IsNullEvaluator(DriverContext driverContext, ExpressionEvaluator field) implements ExpressionEvaluator {
         private static final long BASE_RAM_BYTES_USED = RamUsageEstimator.shallowSizeOfInstance(IsNullEvaluator.class);
 
         @Override

x-pack/plugin/esql/src/test/java/org/elasticsearch/xpack/esql/expression/function/scalar/multivalue/MvContainsTests.java

@@ -341,9 +341,7 @@ protected static List<TestCaseSupplier> anyNullIsNull(
                                     );
                                     return new TestCaseSupplier.TestCase(
                                         typeDataWithNull,
-                                        nullPosition == 0
-                                            ? "MvContainsNullSupersetEvaluator[subsetField=Attribute[channel=1]]"
-                                            : "ConstantBooleanTrueEvaluator",
+                                        nullPosition == 0 ? "IsNullEvaluator[field=Attribute[channel=1]]" : "ConstantTrue",
                                         expectedType.expectedType(nullPosition, DataType.BOOLEAN, originalTestCase),
                                         equalTo(nullPosition == 1)
                                     );