Speed up COALESCE significantly

```
                      before              after
     (operation)   Score   Error       Score   Error  Units
 coalesce_2_noop  75.949 ± 3.961  ->   0.010 ±  0.001 ns/op  99.9%
coalesce_2_eager  99.299 ± 6.959  ->   4.292 ±  0.227 ns/op  95.7%
 coalesce_2_lazy 113.118 ± 5.747  ->  26.746 ±  0.954 ns/op  76.4%
```

We tend to advise folks that "COALESCE is faster than CASE", but, as of
8.16.0/elastic#112295 that wasn't the true. I was working with someone a few
days ago to port a scripted_metric aggregation to ESQL and we saw
COALESCE taking ~60% of the time. That won't do.

The trouble is that CASE and COALESCE have to be *lazy*, meaning that
operations like:
```
COALESCE(a, 1 / b)
```
should never emit a warning if `a` is not `null`, even if `b` is `0`. In
8.16/elastic#112295 CASE grew an optimization where it could operate non-lazily
if it was flagged as "safe". This brings a similar optimization to
COALESCE, see it above as "case_2_eager", a 95.7% improvement.

It also brings and arguably more important optimization - entire-block
execution for COALESCE. The schort version is that, if the first
parameter of COALESCE returns no nulls we can return it without doing
anything lazily. There are a few more cases, but the upshot is that
COALESCE is pretyt much *free* in cases where long strings of results
are `null` or not `null`. That's the `coalesce_2_noop` line.

Finally, when there mixed null and non-null values we were using a
single builder with some fairly inefficient paths. This specializes them
per type and skips some slow null-checking where possible. That's the
`coalesce_2_lazy` result, a more modest 76.4%.

Author: nik9000

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

@@ -96,6 +96,11 @@ public Block eval(Page page) {
                 public void close() {
 
                 }
+
+                @Override
+                public String toString() {
+                    return "ConstantNull";
+                }
             };
         }
 

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

@@ -11,6 +11,7 @@
 import org.elasticsearch.common.io.stream.StreamInput;
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.compute.data.Block;
+import org.elasticsearch.compute.operator.EvalOperator;
 import org.elasticsearch.compute.operator.EvalOperator.ExpressionEvaluator;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
 import org.elasticsearch.xpack.esql.core.expression.Expressions;
@@ -28,14 +29,14 @@
 
 import java.io.IOException;
 import java.util.List;
-import java.util.Map;
 import java.util.stream.Stream;
 
 import static org.elasticsearch.xpack.esql.core.type.DataType.BOOLEAN;
 import static org.elasticsearch.xpack.esql.core.type.DataType.CARTESIAN_POINT;
 import static org.elasticsearch.xpack.esql.core.type.DataType.CARTESIAN_SHAPE;
 import static org.elasticsearch.xpack.esql.core.type.DataType.DATETIME;
 import static org.elasticsearch.xpack.esql.core.type.DataType.DATE_NANOS;
+import static org.elasticsearch.xpack.esql.core.type.DataType.DOUBLE;
 import static org.elasticsearch.xpack.esql.core.type.DataType.GEO_POINT;
 import static org.elasticsearch.xpack.esql.core.type.DataType.GEO_SHAPE;
 import static org.elasticsearch.xpack.esql.core.type.DataType.INTEGER;
@@ -200,26 +201,16 @@ public boolean foldable() {
 
     @Override
     public ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator) {
-        return SUPPORTED.get(dataType()).toEvaluator(toEvaluator, children());
+        return switch (dataType()) {
+            case BOOLEAN -> CoalesceBooleanEvaluator.toEvaluator(toEvaluator, children());
+            case DOUBLE, COUNTER_DOUBLE -> CoalesceDoubleEvaluator.toEvaluator(toEvaluator, children());
+            case INTEGER, COUNTER_INTEGER -> CoalesceIntEvaluator.toEvaluator(toEvaluator, children());
+            case LONG, DATE_NANOS, DATETIME, COUNTER_LONG, UNSIGNED_LONG -> CoalesceLongEvaluator.toEvaluator(toEvaluator, children());
+            case KEYWORD, TEXT, SEMANTIC_TEXT, CARTESIAN_POINT, CARTESIAN_SHAPE, GEO_POINT, GEO_SHAPE, IP, VERSION ->
+                CoalesceBytesRefEvaluator.toEvaluator(toEvaluator, children());
+            case NULL -> EvalOperator.CONSTANT_NULL_FACTORY;
+            case UNSUPPORTED, SHORT, BYTE, DATE_PERIOD, OBJECT, DOC_DATA_TYPE, SOURCE, TIME_DURATION, FLOAT, HALF_FLOAT, TSID_DATA_TYPE,
+                SCALED_FLOAT, PARTIAL_AGG -> throw new UnsupportedOperationException("can't be coalesced");
+        };
     }
-
-    interface BuildCoalesce {
-        ExpressionEvaluator.Factory toEvaluator(ToEvaluator toEvaluator, List<Expression> children);
-    }
-
-    private static final Map<DataType, BuildCoalesce> SUPPORTED = Map.ofEntries(
-        // We intend to support all types here.
-        Map.entry(BOOLEAN, CoalesceBooleanEvaluator::toEvaluator),
-        Map.entry(CARTESIAN_POINT, CoalesceBytesRefEvaluator::toEvaluator),
-        Map.entry(CARTESIAN_SHAPE, CoalesceBytesRefEvaluator::toEvaluator),
-        Map.entry(DATE_NANOS, CoalesceLongEvaluator::toEvaluator),
-        Map.entry(DATETIME, CoalesceLongEvaluator::toEvaluator),
-        Map.entry(GEO_POINT, CoalesceBytesRefEvaluator::toEvaluator),
-        Map.entry(GEO_SHAPE, CoalesceBytesRefEvaluator::toEvaluator),
-        Map.entry(INTEGER, CoalesceIntEvaluator::toEvaluator),
-        Map.entry(IP, CoalesceBytesRefEvaluator::toEvaluator),
-        Map.entry(KEYWORD, CoalesceBytesRefEvaluator::toEvaluator),
-        Map.entry(LONG, CoalesceLongEvaluator::toEvaluator),
-        Map.entry(VERSION, CoalesceBytesRefEvaluator::toEvaluator)
-    );
 }

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

@@ -47,6 +47,7 @@
 import static org.elasticsearch.xpack.esql.EsqlTestUtils.randomLiteral;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;
+import static org.hamcrest.Matchers.nullValue;
 import static org.hamcrest.Matchers.sameInstance;
 
 public class CoalesceTests extends AbstractScalarFunctionTestCase {
@@ -57,7 +58,7 @@ public CoalesceTests(@Name("TestCase") Supplier<TestCaseSupplier.TestCase> testC
     @ParametersFactory
     public static Iterable<Object[]> parameters() {
         List<TestCaseSupplier> noNullsSuppliers = new ArrayList<>();
-        VaragsTestCaseBuilder builder = new VaragsTestCaseBuilder(type -> "CoalesceEager");
+        VaragsTestCaseBuilder builder = new VaragsTestCaseBuilder(type -> "Coalesce" + type + "Eager");
         builder.expectString(strings -> strings.filter(v -> v != null).findFirst());
         builder.expectLong(longs -> longs.filter(v -> v != null).findFirst());
         builder.expectInt(ints -> ints.filter(v -> v != null).findFirst());
@@ -72,7 +73,7 @@ public static Iterable<Object[]> parameters() {
                     new TestCaseSupplier.TypedData(first, DataType.IP, "first"),
                     new TestCaseSupplier.TypedData(second, DataType.IP, "second")
                 ),
-                "CoalesceEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]",
+                "CoalesceBytesRefEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]",
                 DataType.IP,
                 equalTo(first == null ? second : first)
             );
@@ -87,7 +88,7 @@ public static Iterable<Object[]> parameters() {
                     new TestCaseSupplier.TypedData(first, DataType.VERSION, "first"),
                     new TestCaseSupplier.TypedData(second, DataType.VERSION, "second")
                 ),
-                "CoalesceEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]",
+                "CoalesceBytesRefEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]",
                 DataType.VERSION,
                 equalTo(first == null ? second : first)
             );
@@ -100,7 +101,7 @@ public static Iterable<Object[]> parameters() {
                     new TestCaseSupplier.TypedData(firstDate, DataType.DATETIME, "first"),
                     new TestCaseSupplier.TypedData(secondDate, DataType.DATETIME, "second")
                 ),
-                "CoalesceEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]",
+                "CoalesceLongEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]",
                 DataType.DATETIME,
                 equalTo(firstDate == null ? secondDate : firstDate)
             );
@@ -113,7 +114,7 @@ public static Iterable<Object[]> parameters() {
                     new TestCaseSupplier.TypedData(firstDate, DataType.DATE_NANOS, "first"),
                     new TestCaseSupplier.TypedData(secondDate, DataType.DATE_NANOS, "second")
                 ),
-                "CoalesceEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]",
+                "CoalesceLongEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]",
                 DataType.DATE_NANOS,
                 equalTo(firstDate == null ? secondDate : firstDate)
             );
@@ -137,6 +138,20 @@ public static Iterable<Object[]> parameters() {
                 suppliers.add(new TestCaseSupplier(nullCaseName(s, nullUpTo, true), types, () -> nullCase(s.get(), finalNullUpTo, true)));
             }
         }
+        suppliers.add(
+            new TestCaseSupplier(
+                List.of(DataType.NULL, DataType.NULL),
+                () -> new TestCaseSupplier.TestCase(
+                    List.of(
+                        new TestCaseSupplier.TypedData(null, DataType.NULL, "first"),
+                        new TestCaseSupplier.TypedData(null, DataType.NULL, "second")
+                    ),
+                    "ConstantNull",
+                    DataType.NULL,
+                    nullValue()
+                )
+            )
+        );
 
         return parameterSuppliersFromTypedData(suppliers);
     }
@@ -175,7 +190,7 @@ protected static void addSpatialCombinations(List<TestCaseSupplier> suppliers) {
                 TestCaseSupplier.testCaseSupplier(
                     leftDataSupplier,
                     rightDataSupplier,
-                    (l, r) -> equalTo("CoalesceEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]"),
+                    (l, r) -> equalTo("CoalesceBytesRefEagerEvaluator[values=[Attribute[channel=0], Attribute[channel=1]]]"),
                     dataType,
                     (l, r) -> l
                 )
@@ -243,7 +258,11 @@ public void testCoalesceNotNullable() {
         sub.add(between(0, sub.size()), randomLiteral(sub.get(sub.size() - 1).dataType()));
         Coalesce exp = build(Source.EMPTY, sub);
         // Known not to be nullable because it contains a non-null literal
-        assertThat(exp.nullable(), equalTo(Nullability.FALSE));
+        if (testCase.expectedType() == DataType.NULL) {
+            assertThat(exp.nullable(), equalTo(Nullability.UNKNOWN));
+        } else {
+            assertThat(exp.nullable(), equalTo(Nullability.FALSE));
+        }
     }
 
     /**