ESQL: Union Types Support (#107545)

* Union Types Support

The second prototype replaced MultiTypeField.Unresolved with MultiTypeField, but this clashed with existing behaviour around mapping unused MultiTypeFields to `unsupported` and `null`, so this new attempt simply adds new fields, resulting in more than one field with the same name.
We still need to store this new field in EsRelation, so that physical planner can insert it into FieldExtractExec, so this is quite similar to the second protototype.

The following query works in this third prototype:

```
multiIndexIpString
FROM sample_data* METADATA _index
| EVAL client_ip = TO_IP(client_ip)
| KEEP _index, @timestamp, client_ip, event_duration, message
| SORT _index ASC, @timestamp DESC
```

As with the previous prototyep, we no longer need an aggregation to force the conversion function onto the data node, as the 'real' conversion is now done at field extraction time using the converter function previously saved in the EsRelation and replanned into the EsQueryExec.

Support row-stride-reader for LoadFromMany

Add missing ESQL version after rebase on main

Fixed missing block release

Simplify UnresolvedUnionTypes

Support other commands, notably WHERE

Update docs/changelog/107545.yaml

Fix changelog

Removed unused code

Slight code reduction in analyser of union types

Removed unused interface method

Fix bug in copying blocks (array overrun)

Convert MultiTypeEsField.UnresolvedField back to InvalidMappedField

This is to ensure older behaviour still works.

Simplify InvalidMappedField support

Rather than complex code to recreate InvalidMappedField from MultiTypeEsField.UnresolvedField, we rely on the fact that this is the parent class anyway, so we can resolve this during plan serialization/deserialization anyway. Much simpler

Simplify InvalidMappedField support further

Combining InvalidMappedField and MultiTypeEsField.UnresolvedField into one class simplifies plan serialization even further.

InvalidMappedField is used slightly differently in QL

We need to separate the aggregatable used in the original really-invalid mapped field from the aggregatable used if the field can indeed be used as a union-type in ES|QL.

Updated version limitation after 8.14 branch

Try debug CI failures in multi-node clusters

Support type conversion in rowstride reader on single leaf

Disable union_types from CsvTests

Keep track of per-shard converters for LoadFromMany

Simplify block loader convert function

Code cleanup

Added unit test for ValuesSourceReaderOperator including field type conversions at block loading

Added test for @timestamp and fixed related bug

It turns out that most, but not all, DataType values have the same esType as typeName, and @timestamp is one that does not, using `date` for esType and `datetime` for typename. Our EsqlIndexResolver was recording multi-type fields with `esType`, while later the actual type conversion was using an evaluator that relied on DataTypes.typeFromName(typeName).
So we fixed the EsqlIndexResolver to rather use typeName.

Added more tests, with three indices combined and two type conversions

Disable lucene-pushdown on union-type fields

Since the union-type rewriter replaced conversion functions with new FieldAttributes, these were passing the check for being possible to push-down, which was incorrect. Now we prevent that.

Set union-type aggregatable flag to false always

This simplifies the push-down check.

Fixed tests after rebase on main

Add unit tests for union-types (same field, different type)

Remove generic warnings

Test code cleanup and clarifying comments

Remove -IT_tests_only in favor of CsvTests assumeFalse

Improved comment

Code review updates

Code review updates

Remove changes to ql/EsRelation

And it turned out the latest version of union type no longer needed these changes anyway, and was using the new EsRelation in the ESQL module without these changes.

Port InvalidMappedField to ESQL

Note, this extends the QL version of InvalidMappedField, so is not a complete port. This is necessary because of the intertwining of QL IndexResolver and EsqlIndexResolver. Once those classes are disentangled, we can completely break InvalidMappedField from QL and make it a forbidden type.

Fix capabilities line after rebase on main

Revert QL FieldAttribute and extend with ESQL FieldAttribute

So as to remove any edits to QL code, we extend FieldAttribute in the ESQL code with the changes required, since is simply to include the `field` in the hascode and equals methods.

Revert "Revert QL FieldAttribute and extend with ESQL FieldAttribute"

This reverts commit 168c6c75436e26b83e083cd3de8e18062e116bc9.

Switch UNION_TYPES from EsqlFeatures to EsqlCapabilities

Make hashcode and equals aligned

And removed unused method from earlier union-types work where we kept the NodeId during re-writing (which we no longer do).

Replace required_feature with required_capability after rebase

Switch union_types capability back to feature, because capabilities do not work in mixed clusters

Revert "Switch union_types capability back to feature, because capabilities do not work in mixed clusters"

This reverts commit 56d58bedf756dbad703c07bf4cdb991d4341c1ae.

Added test for multiple columns from same fields

Both IP and Date are tested

Fix bug with incorrectly resolving invalid types

And added more tests

Fixed bug with multiple fields of same name

This fix simply removes the original field already at the EsRelation level, which covers all test cases but has the side effect of having the final field no-longer be unsupported/null when the alias does not overwrite the field with the same name.
This is not exactly the correct semantic intent.
The original field name should be unsupported/null unless the user explicitly overwrote the name with `field=TO_TYPE(field)`, which effectively deletes the old field anyway.

Fixed bug with multiple conversions of the same field

This also fixes the issue with the previous fix that incorrectly reported the converted type for the original field.

More tests with multiple fields and KEEP/DROP combinations

Replace skip with capabilities in YML tests

Fixed missing ql->esql import change afer merging main

Merged two InvalidMappedField classes

After the QL code was ported to esql.core, we can now make the edits directly in InvalidMappedField instead of having one extend the other.

Move FieldAttribute edits from QL to ESQL

ESQL: Prepare analyzer for LOOKUP (#109045)

This extracts two fairly uncontroversial changes that were in the main
LOOKUP PR into a smaller change that's easier to review.

ESQL: Move serialization for EsField (#109222)

This moves the serialization logic for `EsField` into the `EsField`
subclasses to better align with the way rest of Elasticsearch works. It
also switches them from ESQL's home grown `writeNamed` thing to
`NamedWriteable`. These are wire compatible with one another.

ESQL: Move serialization of `Attribute` (#109267)

This moves the serialization of `Attribute` classes used in ESQL into
the classes themselves to better line up with the rest of Elasticsearch.

ES|QL: add MV_APPEND function (#107001)

Adding `MV_APPEND(value1, value2)` function, that appends two values
creating a single multi-value. If one or both the inputs are
multi-values, the result is the concatenation of all the values, eg.

```
MV_APPEND([a, b], [c, d]) -> [a, b, c, d]
```

~I think for this specific case it makes sense to consider `null` values
as empty arrays, so that~ ~MV_APPEND(value, null) -> value~ ~It is
pretty uncommon for ESQL (all the other functions, apart from
`COALESCE`, short-circuit to `null` when one of the values is null), so
let's discuss this behavior.~

[EDIT] considering the feedback from Andrei, I changed this logic and
made it consistent with the other functions: now if one of the
parameters is null, the function returns null

[ES|QL] Convert string to datetime when the other size of an arithmetic operator is date_period or time_duration (#108455)

* convert string to datetime when the other side of binary operator is temporal amount

ESQL: Move `NamedExpression` serialization (#109380)

This moves the serialization for the remaining `NamedExpression`
subclass into the class itself, and switches all direct serialization of
`NamedExpression`s to `readNamedWriteable` and friends. All other
`NamedExpression` subclasses extend from `Attribute` who's serialization
was moved ealier. They are already registered under the "category class"
for `Attribute`. This also registers them as `NamedExpression`s.

ESQL: Implement LOOKUP, an "inline" enrich (#107987)

This adds support for `LOOKUP`, a command that implements a sort of
inline `ENRICH`, using data that is passed in the request:

```
$ curl -uelastic:password -HContent-Type:application/json -XPOST \
    'localhost:9200/_query?error_trace&pretty&format=txt' \
-d'{
    "query": "ROW a=1::LONG | LOOKUP t ON a",
    "tables": {
        "t": {
            "a:long":     [    1,     4,     2],
            "v1:integer": [   10,    11,    12],
            "v2:keyword": ["cat", "dog", "wow"]
        }
    },
    "version": "2024.04.01"
}'
      v1       |      v2       |       a
---------------+---------------+---------------
10             |cat            |1
```

This required these PRs: * #107624 * #107634 * #107701 * #107762 *

Closes #107306

parent 32ac5ba755dd5c24364a210f1097ae093fdcbd75
author Craig Taverner <[email protected]> 1717779549 +0200
committer Craig Taverner <[email protected]> 1718115775 +0200

Fixed compile error after merging in main

Fixed strange merge issues from main

Remove version from ES|QL test queries after merging main

Fixed union-types on nested fields

Switch to Luigi's solution, and expand nested tests

Cleanup after rebase

* Added more tests from code review

Note that one test, `multiIndexIpStringStatsInline` is muted due to failing with the error:

    UnresolvedException: Invalid call to dataType on an unresolved object ?client_ip

* Make CsvTests consistent with integration tests for capabilities

The integration tests do not fail the tests if the capability does not even exist on cluster nodes, instead the tests are ignored. The same behaviour should happen with CsvTests for consistency.

* Return assumeThat to assertThat, but change order

This way we don't have to add more features to the test framework in this PR, but we would probably want a mute feature (like a `skip` line).

* Move serialization of MultiTypeEsField to NamedWritable approach

Since the sub-fields are AbstractConvertFunction expressions, and Expression is not yet fully supported as a category class for NamedWritable, we need a few slight tweaks to this, notably registering this explicitly in the EsqlPlugin, as well as calling PlanStreamInput.readExpression() instead of StreamInput.readNamedWritable(Expression.class). These can be removed later once Expression is fully supported as a category class.

* Remove attempt to mute two failed tests

We used required_capability to mute the tests, but this caused issues with CsvTests which also uses this as a spelling mistake checker for typing the capability name wrong, so we tried to use muted-tests.yml, but that only mutes tests in specific run configurations (ie. we need to mute each and every IT class separately).

So now we just remove the tests entirely. We left a comment in the muted-tests.yml file for future reference about how to mute csv-spec tests.

* Fix rather massive issue with performance of testConcurrentSerialization

Recreating the config on every test was very expensive.

* Code review by Nik

---------

Co-authored-by: Elastic Machine <[email protected]>

Author: craigtaverner

docs/changelog/107545.yaml

@@ -0,0 +1,6 @@
+pr: 107545
+summary: "ESQL: Union Types Support"
+area: ES|QL
+type: enhancement
+issues:
+ - 100603

muted-tests.yml

@@ -103,3 +103,10 @@ tests:
 #  - class: org.elasticsearch.xpack.esql.expression.function.scalar.convert.ToIPTests
 #    method: testCrankyEvaluateBlockWithoutNulls
 #    issue: https://github.com/elastic/elasticsearch/...
+#
+#  Mute a single test in an ES|QL csv-spec test file:
+#  - class: "org.elasticsearch.xpack.esql.CsvTests"
+#    method: "test {union_types.MultiIndexIpStringStatsInline}"
+#    issue: "https://github.com/elastic/elasticsearch/..."
+#  Note that this mutes for the unit-test-like CsvTests only.
+#  Muting for the integration tests needs to be done for each IT class individually.

server/src/main/java/org/elasticsearch/index/mapper/BlockLoader.java

@@ -92,6 +92,16 @@ interface StoredFields {
      */
     SortedSetDocValues ordinals(LeafReaderContext context) throws IOException;
 
+    /**
+     * In support of 'Union Types', we sometimes desire that Blocks loaded from source are immediately
+     * converted in some way. Typically, this would be a type conversion, or an encoding conversion.
+     * @param block original block loaded from source
+     * @return converted block (or original if no conversion required)
+     */
+    default Block convert(Block block) {
+        return block;
+    }
+
     /**
      * Load blocks with only null.
      */

x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/expression/FieldAttribute.java

@@ -168,12 +168,14 @@ protected Attribute clone(
 
     @Override
     public int hashCode() {
-        return Objects.hash(super.hashCode(), path);
+        return Objects.hash(super.hashCode(), path, field);
     }
 
     @Override
     public boolean equals(Object obj) {
-        return super.equals(obj) && Objects.equals(path, ((FieldAttribute) obj).path);
+        return super.equals(obj)
+            && Objects.equals(path, ((FieldAttribute) obj).path)
+            && Objects.equals(field, ((FieldAttribute) obj).field);
     }
 
     @Override

x-pack/plugin/esql-core/src/main/java/org/elasticsearch/xpack/esql/core/type/InvalidMappedField.java

@@ -15,11 +15,15 @@
 import java.io.IOException;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import java.util.TreeMap;
 
 /**
  * Representation of field mapped differently across indices.
  * Used during mapping discovery only.
+ * Note that the field <code>typesToIndices</code> is not serialized because that information is
+ * not required through the cluster, only surviving as long as the Analyser phase of query planning.
+ * It is used specifically for the 'union types' feature in ES|QL.
  */
 public class InvalidMappedField extends EsField {
     static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(
@@ -29,10 +33,10 @@ public class InvalidMappedField extends EsField {
     );
 
     private final String errorMessage;
+    private final Map<String, Set<String>> typesToIndices;
 
     public InvalidMappedField(String name, String errorMessage, Map<String, EsField> properties) {
-        super(name, DataType.UNSUPPORTED, properties, false);
-        this.errorMessage = errorMessage;
+        this(name, errorMessage, properties, Map.of());
     }
 
     public InvalidMappedField(String name, String errorMessage) {
@@ -43,6 +47,19 @@ public InvalidMappedField(String name) {
         this(name, StringUtils.EMPTY, new TreeMap<>());
     }
 
+    /**
+     * Constructor supporting union types, used in ES|QL.
+     */
+    public InvalidMappedField(String name, Map<String, Set<String>> typesToIndices) {
+        this(name, makeErrorMessage(typesToIndices), new TreeMap<>(), typesToIndices);
+    }
+
+    private InvalidMappedField(String name, String errorMessage, Map<String, EsField> properties, Map<String, Set<String>> typesToIndices) {
+        super(name, DataType.UNSUPPORTED, properties, false);
+        this.errorMessage = errorMessage;
+        this.typesToIndices = typesToIndices;
+    }
+
     private InvalidMappedField(StreamInput in) throws IOException {
         this(in.readString(), in.readString(), in.readImmutableMap(StreamInput::readString, i -> i.readNamedWriteable(EsField.class)));
     }
@@ -88,4 +105,28 @@ public EsField getExactField() {
     public Exact getExactInfo() {
         return new Exact(false, "Field [" + getName() + "] is invalid, cannot access it");
     }
+
+    public Map<String, Set<String>> getTypesToIndices() {
+        return typesToIndices;
+    }
+
+    private static String makeErrorMessage(Map<String, Set<String>> typesToIndices) {
+        StringBuilder errorMessage = new StringBuilder();
+        errorMessage.append("mapped as [");
+        errorMessage.append(typesToIndices.size());
+        errorMessage.append("] incompatible types: ");
+        boolean first = true;
+        for (Map.Entry<String, Set<String>> e : typesToIndices.entrySet()) {
+            if (first) {
+                first = false;
+            } else {
+                errorMessage.append(", ");
+            }
+            errorMessage.append("[");
+            errorMessage.append(e.getKey());
+            errorMessage.append("] in ");
+            errorMessage.append(e.getValue());
+        }
+        return errorMessage.toString();
+    }
 }

x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/data/Page.java

@@ -83,7 +83,9 @@ private Page(boolean copyBlocks, int positionCount, Block[] blocks) {
     private Page(Page prev, Block[] toAdd) {
         for (Block block : toAdd) {
             if (prev.positionCount != block.getPositionCount()) {
-                throw new IllegalArgumentException("Block [" + block + "] does not have same position count");
+                throw new IllegalArgumentException(
+                    "Block [" + block + "] does not have same position count: " + block.getPositionCount() + " != " + prev.positionCount
+                );
             }
         }
         this.positionCount = prev.positionCount;

x-pack/plugin/esql/compute/src/main/java/org/elasticsearch/compute/lucene/ValuesSourceReaderOperator.java

@@ -165,14 +165,14 @@ public int get(int i) {
                 }
             }
             success = true;
+            return page.appendBlocks(blocks);
         } catch (IOException e) {
             throw new UncheckedIOException(e);
         } finally {
             if (success == false) {
                 Releasables.closeExpectNoException(blocks);
             }
         }
-        return page.appendBlocks(blocks);
     }
 
     private void positionFieldWork(int shard, int segment, int firstDoc) {
@@ -233,6 +233,7 @@ private void loadFromSingleLeaf(Block[] blocks, int shard, int segment, BlockLoa
                         new RowStrideReaderWork(
                             field.rowStride(ctx),
                             (Block.Builder) field.loader.builder(loaderBlockFactory, docs.count()),
+                            field.loader,
                             f
                         )
                     );
@@ -262,17 +263,13 @@ private void loadFromSingleLeaf(Block[] blocks, int shard, int segment, BlockLoa
             );
             for (int p = 0; p < docs.count(); p++) {
                 int doc = docs.get(p);
-                if (storedFields != null) {
-                    storedFields.advanceTo(doc);
-                }
-                for (int r = 0; r < rowStrideReaders.size(); r++) {
-                    RowStrideReaderWork work = rowStrideReaders.get(r);
-                    work.reader.read(doc, storedFields, work.builder);
+                storedFields.advanceTo(doc);
+                for (RowStrideReaderWork work : rowStrideReaders) {
+                    work.read(doc, storedFields);
                 }
             }
-            for (int r = 0; r < rowStrideReaders.size(); r++) {
-                RowStrideReaderWork work = rowStrideReaders.get(r);
-                blocks[work.offset] = work.builder.build();
+            for (RowStrideReaderWork work : rowStrideReaders) {
+                blocks[work.offset] = work.build();
             }
         } finally {
             Releasables.close(rowStrideReaders);
@@ -310,7 +307,9 @@ private class LoadFromMany implements Releasable {
         private final IntVector docs;
         private final int[] forwards;
         private final int[] backwards;
-        private final Block.Builder[] builders;
+        private final Block.Builder[][] builders;
+        private final BlockLoader[][] converters;
+        private final Block.Builder[] fieldTypeBuilders;
         private final BlockLoader.RowStrideReader[] rowStride;
 
         BlockLoaderStoredFieldsFromLeafLoader storedFields;
@@ -322,29 +321,34 @@ private class LoadFromMany implements Releasable {
             docs = docVector.docs();
             forwards = docVector.shardSegmentDocMapForwards();
             backwards = docVector.shardSegmentDocMapBackwards();
-            builders = new Block.Builder[target.length];
+            fieldTypeBuilders = new Block.Builder[target.length];
+            builders = new Block.Builder[target.length][shardContexts.size()];
+            converters = new BlockLoader[target.length][shardContexts.size()];
             rowStride = new BlockLoader.RowStrideReader[target.length];
         }
 
         void run() throws IOException {
             for (int f = 0; f < fields.length; f++) {
                 /*
-                 * Important note: each block loader has a method to build an
-                 * optimized block loader, but we have *many* fields and some
-                 * of those block loaders may not be compatible with each other.
-                 * So! We take the least common denominator which is the loader
-                 * from the element expected element type.
+                 * Important note: each field has a desired type, which might not match the mapped type (in the case of union-types).
+                 * We create the final block builders using the desired type, one for each field, but then also use inner builders
+                 * (one for each field and shard), and converters (again one for each field and shard) to actually perform the field
+                 * loading in a way that is correct for the mapped field type, and then convert between that type and the desired type.
                  */
-                builders[f] = fields[f].info.type.newBlockBuilder(docs.getPositionCount(), blockFactory);
+                fieldTypeBuilders[f] = fields[f].info.type.newBlockBuilder(docs.getPositionCount(), blockFactory);
+                builders[f] = new Block.Builder[shardContexts.size()];
+                converters[f] = new BlockLoader[shardContexts.size()];
             }
+            ComputeBlockLoaderFactory loaderBlockFactory = new ComputeBlockLoaderFactory(blockFactory, docs.getPositionCount());
             int p = forwards[0];
             int shard = shards.getInt(p);
             int segment = segments.getInt(p);
             int firstDoc = docs.getInt(p);
             positionFieldWork(shard, segment, firstDoc);
             LeafReaderContext ctx = ctx(shard, segment);
             fieldsMoved(ctx, shard);
-            read(firstDoc);
+            verifyBuilders(loaderBlockFactory, shard);
+            read(firstDoc, shard);
             for (int i = 1; i < forwards.length; i++) {
                 p = forwards[i];
                 shard = shards.getInt(p);
@@ -354,11 +358,19 @@ void run() throws IOException {
                     ctx = ctx(shard, segment);
                     fieldsMoved(ctx, shard);
                 }
-                read(docs.getInt(p));
+                verifyBuilders(loaderBlockFactory, shard);
+                read(docs.getInt(p), shard);
             }
-            for (int f = 0; f < builders.length; f++) {
-                try (Block orig = builders[f].build()) {
-                    target[f] = orig.filter(backwards);
+            for (int f = 0; f < target.length; f++) {
+                for (int s = 0; s < shardContexts.size(); s++) {
+                    if (builders[f][s] != null) {
+                        try (Block orig = (Block) converters[f][s].convert(builders[f][s].build())) {
+                            fieldTypeBuilders[f].copyFrom(orig, 0, orig.getPositionCount());
+                        }
+                    }
+                }
+                try (Block targetBlock = fieldTypeBuilders[f].build()) {
+                    target[f] = targetBlock.filter(backwards);
                 }
             }
         }
@@ -379,16 +391,29 @@ private void fieldsMoved(LeafReaderContext ctx, int shard) throws IOException {
             }
         }
 
-        private void read(int doc) throws IOException {
+        private void verifyBuilders(ComputeBlockLoaderFactory loaderBlockFactory, int shard) {
+            for (int f = 0; f < fields.length; f++) {
+                if (builders[f][shard] == null) {
+                    // Note that this relies on field.newShard() to set the loader and converter correctly for the current shard
+                    builders[f][shard] = (Block.Builder) fields[f].loader.builder(loaderBlockFactory, docs.getPositionCount());
+                    converters[f][shard] = fields[f].loader;
+                }
+            }
+        }
+
+        private void read(int doc, int shard) throws IOException {
             storedFields.advanceTo(doc);
             for (int f = 0; f < builders.length; f++) {
-                rowStride[f].read(doc, storedFields, builders[f]);
+                rowStride[f].read(doc, storedFields, builders[f][shard]);
             }
         }
 
         @Override
         public void close() {
-            Releasables.closeExpectNoException(builders);
+            Releasables.closeExpectNoException(fieldTypeBuilders);
+            for (int f = 0; f < fields.length; f++) {
+                Releasables.closeExpectNoException(builders[f]);
+            }
         }
     }
 
@@ -468,7 +493,17 @@ private void trackReader(String type, BlockLoader.Reader reader) {
         }
     }
 
-    private record RowStrideReaderWork(BlockLoader.RowStrideReader reader, Block.Builder builder, int offset) implements Releasable {
+    private record RowStrideReaderWork(BlockLoader.RowStrideReader reader, Block.Builder builder, BlockLoader loader, int offset)
+        implements
+            Releasable {
+        void read(int doc, BlockLoaderStoredFieldsFromLeafLoader storedFields) throws IOException {
+            reader.read(doc, storedFields, builder);
+        }
+
+        Block build() {
+            return (Block) loader.convert(builder.build());
+        }
+
         @Override
         public void close() {
             builder.close();