Skip to content

Commit a19a0ab

Browse files
not-napoleonelasticmachine
authored and
georgewallace
committed
[ESQL] Enable "any type" aggregations on Date Nanos (elastic#114438)
Resolves elastic#110002 Resolves elastic#110003 Resolves elastic#110005 Enable Values, Count, CountDistinct, Min and Max aggregations on date nanos. In the course of addressing this, I had to make some changes to AggregateMapper where it maps types into string names. I tried to refactor this once before (elastic#110841) but at the time we decided not to go ahead with it. That bit me while working on this, and so I am trying again to refactor it. This time I've made a more localized change, just replacing the cascading if block with a switch. That will cause a compile time failure when future new data types are added, unless they correctly update this section. I've also done a small refactoring on the aggregators themselves, to make the supplier function consistent with the typeResolution. --------- Co-authored-by: Elastic Machine <[email protected]>
1 parent b106c62 commit a19a0ab

File tree

8 files changed

+131
-99
lines changed

8 files changed

+131
-99
lines changed

‎x-pack/plugin/esql/qa/testFixtures/src/main/resources/date_nanos.csv‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6,5 +6,6 @@ millis:date,nanos:date_nanos,num:long
66
2023-10-23T13:33:34.937Z,2023-10-23T13:33:34.937193000Z,1698068014937193000
77
2023-10-23T12:27:28.948Z,2023-10-23T12:27:28.948000000Z,1698064048948000000
88
2023-10-23T12:15:03.360Z,2023-10-23T12:15:03.360103847Z,1698063303360103847
9+
2023-10-23T12:15:03.360Z,2023-10-23T12:15:03.360103847Z,1698063303360103847
910
1999-10-23T12:15:03.360Z,[2023-03-23T12:15:03.360103847Z, 2023-02-23T13:33:34.937193000Z, 2023-01-23T13:55:01.543123456Z], 0
1011
1999-10-22T12:15:03.360Z,[2023-03-23T12:15:03.360103847Z, 2023-03-23T12:15:03.360103847Z, 2023-03-23T12:15:03.360103847Z], 0

‎x-pack/plugin/esql/qa/testFixtures/src/main/resources/date_nanos.csv-spec‎

Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -216,6 +216,7 @@ l:long
216216
1698068014937193000
217217
1698064048948000000
218218
1698063303360103847
219+
1698063303360103847
219220
;
220221

221222
long to date nanos, index version
@@ -231,6 +232,7 @@ d:date_nanos
231232
2023-10-23T13:33:34.937193000Z
232233
2023-10-23T12:27:28.948000000Z
233234
2023-10-23T12:15:03.360103847Z
235+
2023-10-23T12:15:03.360103847Z
234236
;
235237

236238
date_nanos to date nanos, index version
@@ -246,6 +248,7 @@ d:date_nanos
246248
2023-10-23T13:33:34.937193000Z
247249
2023-10-23T12:27:28.948000000Z
248250
2023-10-23T12:15:03.360103847Z
251+
2023-10-23T12:15:03.360103847Z
249252
;
250253

251254
attempt to cast the result of a fold to date nanos
@@ -331,3 +334,31 @@ a:date_nanos
331334
[2023-02-23T13:33:34.937193000Z, 2023-03-23T12:15:03.360103847Z]
332335
[2023-03-23T12:15:03.360103847Z, 2023-03-23T12:15:03.360103847Z]
333336
;
337+
338+
339+
Max and Min of date nanos
340+
required_capability: date_nanos_aggregations
341+
342+
FROM date_nanos | STATS max = MAX(nanos), min = MIN(nanos);
343+
344+
max:date_nanos | min:date_nanos
345+
2023-10-23T13:55:01.543123456Z | 2023-01-23T13:55:01.543123456Z
346+
;
347+
348+
Count and count distinct of date nanos
349+
required_capability: date_nanos_aggregations
350+
351+
FROM date_nanos | WHERE millis > "2020-01-01" | STATS count = COUNT(nanos), count_distinct = COUNT_DISTINCT(nanos);
352+
353+
count:long | count_distinct:long
354+
8 | 7
355+
;
356+
357+
Values aggregation on date nanos
358+
required_capability: date_nanos_aggregations
359+
360+
FROM date_nanos | WHERE millis > "2020-01-01" | STATS v = MV_SORT(VALUES(nanos), "DESC");
361+
362+
v:date_nanos
363+
[2023-10-23T13:55:01.543123456Z, 2023-10-23T13:53:55.832987654Z, 2023-10-23T13:52:55.015787878Z, 2023-10-23T13:51:54.732102837Z, 2023-10-23T13:33:34.937193000Z, 2023-10-23T12:27:28.948000000Z, 2023-10-23T12:15:03.360103847Z]
364+
;

‎x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/action/EsqlCapabilities.java‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -313,6 +313,11 @@ public enum Cap {
313313
*/
314314
LEAST_GREATEST_FOR_DATENANOS(EsqlCorePlugin.DATE_NANOS_FEATURE_FLAG),
315315

316+
/**
317+
* support aggregations on date nanos
318+
*/
319+
DATE_NANOS_AGGREGATIONS(EsqlCorePlugin.DATE_NANOS_FEATURE_FLAG),
320+
316321
/**
317322
* Support for datetime in least and greatest functions
318323
*/

‎x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/CountDistinct.java‎

Lines changed: 22 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,8 @@
3838

3939
import java.io.IOException;
4040
import java.util.List;
41+
import java.util.Map;
42+
import java.util.function.BiFunction;
4143

4244
import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.DEFAULT;
4345
import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.SECOND;
@@ -53,6 +55,20 @@ public class CountDistinct extends AggregateFunction implements OptionalArgument
5355
CountDistinct::new
5456
);
5557

58+
private static final Map<DataType, BiFunction<List<Integer>, Integer, AggregatorFunctionSupplier>> SUPPLIERS = Map.ofEntries(
59+
// Booleans ignore the precision because there are only two possible values anyway
60+
Map.entry(DataType.BOOLEAN, (inputChannels, precision) -> new CountDistinctBooleanAggregatorFunctionSupplier(inputChannels)),
61+
Map.entry(DataType.LONG, CountDistinctLongAggregatorFunctionSupplier::new),
62+
Map.entry(DataType.DATETIME, CountDistinctLongAggregatorFunctionSupplier::new),
63+
Map.entry(DataType.DATE_NANOS, CountDistinctLongAggregatorFunctionSupplier::new),
64+
Map.entry(DataType.INTEGER, CountDistinctIntAggregatorFunctionSupplier::new),
65+
Map.entry(DataType.DOUBLE, CountDistinctDoubleAggregatorFunctionSupplier::new),
66+
Map.entry(DataType.KEYWORD, CountDistinctBytesRefAggregatorFunctionSupplier::new),
67+
Map.entry(DataType.IP, CountDistinctBytesRefAggregatorFunctionSupplier::new),
68+
Map.entry(DataType.VERSION, CountDistinctBytesRefAggregatorFunctionSupplier::new),
69+
Map.entry(DataType.TEXT, CountDistinctBytesRefAggregatorFunctionSupplier::new)
70+
);
71+
5672
private static final int DEFAULT_PRECISION = 3000;
5773
private final Expression precision;
5874

@@ -102,7 +118,7 @@ public CountDistinct(
102118
Source source,
103119
@Param(
104120
name = "field",
105-
type = { "boolean", "date", "double", "integer", "ip", "keyword", "long", "text", "version" },
121+
type = { "boolean", "date", "date_nanos", "double", "integer", "ip", "keyword", "long", "text", "version" },
106122
description = "Column or literal for which to count the number of distinct values."
107123
) Expression field,
108124
@Param(
@@ -179,7 +195,7 @@ protected TypeResolution resolveType() {
179195
.and(
180196
isType(
181197
field(),
182-
dt -> dt != DataType.UNSIGNED_LONG && dt != DataType.SOURCE,
198+
SUPPLIERS::containsKey,
183199
sourceText(),
184200
DEFAULT,
185201
"any exact type except unsigned_long, _source, or counter types"
@@ -196,23 +212,11 @@ protected TypeResolution resolveType() {
196212
public AggregatorFunctionSupplier supplier(List<Integer> inputChannels) {
197213
DataType type = field().dataType();
198214
int precision = this.precision == null ? DEFAULT_PRECISION : ((Number) this.precision.fold()).intValue();
199-
if (type == DataType.BOOLEAN) {
200-
// Booleans ignore the precision because there are only two possible values anyway
201-
return new CountDistinctBooleanAggregatorFunctionSupplier(inputChannels);
202-
}
203-
if (type == DataType.DATETIME || type == DataType.LONG) {
204-
return new CountDistinctLongAggregatorFunctionSupplier(inputChannels, precision);
205-
}
206-
if (type == DataType.INTEGER) {
207-
return new CountDistinctIntAggregatorFunctionSupplier(inputChannels, precision);
208-
}
209-
if (type == DataType.DOUBLE) {
210-
return new CountDistinctDoubleAggregatorFunctionSupplier(inputChannels, precision);
211-
}
212-
if (DataType.isString(type) || type == DataType.IP || type == DataType.VERSION) {
213-
return new CountDistinctBytesRefAggregatorFunctionSupplier(inputChannels, precision);
215+
if (SUPPLIERS.containsKey(type) == false) {
216+
// If the type checking did its job, this should never happen
217+
throw EsqlIllegalArgumentException.illegalDataType(type);
214218
}
215-
throw EsqlIllegalArgumentException.illegalDataType(type);
219+
return SUPPLIERS.get(type).apply(inputChannels, precision);
216220
}
217221

218222
@Override

‎x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/Max.java‎

Lines changed: 20 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -32,16 +32,28 @@
3232

3333
import java.io.IOException;
3434
import java.util.List;
35+
import java.util.Map;
36+
import java.util.function.Function;
3537

3638
import static java.util.Collections.emptyList;
3739
import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.DEFAULT;
38-
import static org.elasticsearch.xpack.esql.core.type.DataType.UNSIGNED_LONG;
39-
import static org.elasticsearch.xpack.esql.core.type.DataType.isRepresentable;
40-
import static org.elasticsearch.xpack.esql.core.type.DataType.isSpatial;
4140

4241
public class Max extends AggregateFunction implements ToAggregator, SurrogateExpression {
4342
public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(Expression.class, "Max", Max::new);
4443

44+
private static final Map<DataType, Function<List<Integer>, AggregatorFunctionSupplier>> SUPPLIERS = Map.ofEntries(
45+
Map.entry(DataType.BOOLEAN, MaxBooleanAggregatorFunctionSupplier::new),
46+
Map.entry(DataType.LONG, MaxLongAggregatorFunctionSupplier::new),
47+
Map.entry(DataType.DATETIME, MaxLongAggregatorFunctionSupplier::new),
48+
Map.entry(DataType.DATE_NANOS, MaxLongAggregatorFunctionSupplier::new),
49+
Map.entry(DataType.INTEGER, MaxIntAggregatorFunctionSupplier::new),
50+
Map.entry(DataType.DOUBLE, MaxDoubleAggregatorFunctionSupplier::new),
51+
Map.entry(DataType.IP, MaxIpAggregatorFunctionSupplier::new),
52+
Map.entry(DataType.KEYWORD, MaxBytesRefAggregatorFunctionSupplier::new),
53+
Map.entry(DataType.TEXT, MaxBytesRefAggregatorFunctionSupplier::new),
54+
Map.entry(DataType.VERSION, MaxBytesRefAggregatorFunctionSupplier::new)
55+
);
56+
4557
@FunctionInfo(
4658
returnType = { "boolean", "double", "integer", "long", "date", "ip", "keyword", "text", "long", "version" },
4759
description = "The maximum value of a field.",
@@ -98,7 +110,7 @@ public Max replaceChildren(List<Expression> newChildren) {
98110
protected TypeResolution resolveType() {
99111
return TypeResolutions.isType(
100112
field(),
101-
t -> isRepresentable(t) && t != UNSIGNED_LONG && isSpatial(t) == false,
113+
SUPPLIERS::containsKey,
102114
sourceText(),
103115
DEFAULT,
104116
"representable except unsigned_long and spatial types"
@@ -113,25 +125,11 @@ public DataType dataType() {
113125
@Override
114126
public final AggregatorFunctionSupplier supplier(List<Integer> inputChannels) {
115127
DataType type = field().dataType();
116-
if (type == DataType.BOOLEAN) {
117-
return new MaxBooleanAggregatorFunctionSupplier(inputChannels);
118-
}
119-
if (type == DataType.LONG || type == DataType.DATETIME) {
120-
return new MaxLongAggregatorFunctionSupplier(inputChannels);
121-
}
122-
if (type == DataType.INTEGER) {
123-
return new MaxIntAggregatorFunctionSupplier(inputChannels);
124-
}
125-
if (type == DataType.DOUBLE) {
126-
return new MaxDoubleAggregatorFunctionSupplier(inputChannels);
127-
}
128-
if (type == DataType.IP) {
129-
return new MaxIpAggregatorFunctionSupplier(inputChannels);
130-
}
131-
if (type == DataType.VERSION || DataType.isString(type)) {
132-
return new MaxBytesRefAggregatorFunctionSupplier(inputChannels);
128+
if (SUPPLIERS.containsKey(type) == false) {
129+
// If the type checking did its job, this should never happen
130+
throw EsqlIllegalArgumentException.illegalDataType(type);
133131
}
134-
throw EsqlIllegalArgumentException.illegalDataType(type);
132+
return SUPPLIERS.get(type).apply(inputChannels);
135133
}
136134

137135
@Override

‎x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/Min.java‎

Lines changed: 20 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -32,16 +32,28 @@
3232

3333
import java.io.IOException;
3434
import java.util.List;
35+
import java.util.Map;
36+
import java.util.function.Function;
3537

3638
import static java.util.Collections.emptyList;
3739
import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.DEFAULT;
38-
import static org.elasticsearch.xpack.esql.core.type.DataType.UNSIGNED_LONG;
39-
import static org.elasticsearch.xpack.esql.core.type.DataType.isRepresentable;
40-
import static org.elasticsearch.xpack.esql.core.type.DataType.isSpatial;
4140

4241
public class Min extends AggregateFunction implements ToAggregator, SurrogateExpression {
4342
public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(Expression.class, "Min", Min::new);
4443

44+
private static final Map<DataType, Function<List<Integer>, AggregatorFunctionSupplier>> SUPPLIERS = Map.ofEntries(
45+
Map.entry(DataType.BOOLEAN, MinBooleanAggregatorFunctionSupplier::new),
46+
Map.entry(DataType.LONG, MinLongAggregatorFunctionSupplier::new),
47+
Map.entry(DataType.DATETIME, MinLongAggregatorFunctionSupplier::new),
48+
Map.entry(DataType.DATE_NANOS, MinLongAggregatorFunctionSupplier::new),
49+
Map.entry(DataType.INTEGER, MinIntAggregatorFunctionSupplier::new),
50+
Map.entry(DataType.DOUBLE, MinDoubleAggregatorFunctionSupplier::new),
51+
Map.entry(DataType.IP, MinIpAggregatorFunctionSupplier::new),
52+
Map.entry(DataType.VERSION, MinBytesRefAggregatorFunctionSupplier::new),
53+
Map.entry(DataType.KEYWORD, MinBytesRefAggregatorFunctionSupplier::new),
54+
Map.entry(DataType.TEXT, MinBytesRefAggregatorFunctionSupplier::new)
55+
);
56+
4557
@FunctionInfo(
4658
returnType = { "boolean", "double", "integer", "long", "date", "ip", "keyword", "text", "long", "version" },
4759
description = "The minimum value of a field.",
@@ -98,7 +110,7 @@ public Min withFilter(Expression filter) {
98110
protected TypeResolution resolveType() {
99111
return TypeResolutions.isType(
100112
field(),
101-
t -> isRepresentable(t) && t != UNSIGNED_LONG && isSpatial(t) == false,
113+
SUPPLIERS::containsKey,
102114
sourceText(),
103115
DEFAULT,
104116
"representable except unsigned_long and spatial types"
@@ -113,25 +125,11 @@ public DataType dataType() {
113125
@Override
114126
public final AggregatorFunctionSupplier supplier(List<Integer> inputChannels) {
115127
DataType type = field().dataType();
116-
if (type == DataType.BOOLEAN) {
117-
return new MinBooleanAggregatorFunctionSupplier(inputChannels);
118-
}
119-
if (type == DataType.LONG || type == DataType.DATETIME) {
120-
return new MinLongAggregatorFunctionSupplier(inputChannels);
121-
}
122-
if (type == DataType.INTEGER) {
123-
return new MinIntAggregatorFunctionSupplier(inputChannels);
124-
}
125-
if (type == DataType.DOUBLE) {
126-
return new MinDoubleAggregatorFunctionSupplier(inputChannels);
127-
}
128-
if (type == DataType.IP) {
129-
return new MinIpAggregatorFunctionSupplier(inputChannels);
130-
}
131-
if (type == DataType.VERSION || DataType.isString(type)) {
132-
return new MinBytesRefAggregatorFunctionSupplier(inputChannels);
128+
if (SUPPLIERS.containsKey(type) == false) {
129+
// If the type checking did its job, this should never happen
130+
throw EsqlIllegalArgumentException.illegalDataType(type);
133131
}
134-
throw EsqlIllegalArgumentException.illegalDataType(type);
132+
return SUPPLIERS.get(type).apply(inputChannels);
135133
}
136134

137135
@Override

‎x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/expression/function/aggregate/Values.java‎

Lines changed: 20 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -29,14 +29,28 @@
2929

3030
import java.io.IOException;
3131
import java.util.List;
32+
import java.util.Map;
33+
import java.util.function.Function;
3234

3335
import static java.util.Collections.emptyList;
3436
import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.DEFAULT;
35-
import static org.elasticsearch.xpack.esql.core.type.DataType.UNSIGNED_LONG;
3637

3738
public class Values extends AggregateFunction implements ToAggregator {
3839
public static final NamedWriteableRegistry.Entry ENTRY = new NamedWriteableRegistry.Entry(Expression.class, "Values", Values::new);
3940

41+
private static final Map<DataType, Function<List<Integer>, AggregatorFunctionSupplier>> SUPPLIERS = Map.ofEntries(
42+
Map.entry(DataType.INTEGER, ValuesIntAggregatorFunctionSupplier::new),
43+
Map.entry(DataType.LONG, ValuesLongAggregatorFunctionSupplier::new),
44+
Map.entry(DataType.DATETIME, ValuesLongAggregatorFunctionSupplier::new),
45+
Map.entry(DataType.DATE_NANOS, ValuesLongAggregatorFunctionSupplier::new),
46+
Map.entry(DataType.DOUBLE, ValuesDoubleAggregatorFunctionSupplier::new),
47+
Map.entry(DataType.KEYWORD, ValuesBytesRefAggregatorFunctionSupplier::new),
48+
Map.entry(DataType.TEXT, ValuesBytesRefAggregatorFunctionSupplier::new),
49+
Map.entry(DataType.IP, ValuesBytesRefAggregatorFunctionSupplier::new),
50+
Map.entry(DataType.VERSION, ValuesBytesRefAggregatorFunctionSupplier::new),
51+
Map.entry(DataType.BOOLEAN, ValuesBooleanAggregatorFunctionSupplier::new)
52+
);
53+
4054
@FunctionInfo(
4155
returnType = { "boolean", "date", "double", "integer", "ip", "keyword", "long", "text", "version" },
4256
preview = true,
@@ -98,7 +112,7 @@ public DataType dataType() {
98112
protected TypeResolution resolveType() {
99113
return TypeResolutions.isType(
100114
field(),
101-
dt -> DataType.isSpatial(dt) == false && dt != UNSIGNED_LONG,
115+
SUPPLIERS::containsKey,
102116
sourceText(),
103117
DEFAULT,
104118
"any type except unsigned_long and spatial types"
@@ -108,22 +122,10 @@ protected TypeResolution resolveType() {
108122
@Override
109123
public AggregatorFunctionSupplier supplier(List<Integer> inputChannels) {
110124
DataType type = field().dataType();
111-
if (type == DataType.INTEGER) {
112-
return new ValuesIntAggregatorFunctionSupplier(inputChannels);
113-
}
114-
if (type == DataType.LONG || type == DataType.DATETIME) {
115-
return new ValuesLongAggregatorFunctionSupplier(inputChannels);
116-
}
117-
if (type == DataType.DOUBLE) {
118-
return new ValuesDoubleAggregatorFunctionSupplier(inputChannels);
119-
}
120-
if (DataType.isString(type) || type == DataType.IP || type == DataType.VERSION) {
121-
return new ValuesBytesRefAggregatorFunctionSupplier(inputChannels);
122-
}
123-
if (type == DataType.BOOLEAN) {
124-
return new ValuesBooleanAggregatorFunctionSupplier(inputChannels);
125+
if (SUPPLIERS.containsKey(type) == false) {
126+
// If the type checking did its job, this should never happen
127+
throw EsqlIllegalArgumentException.illegalDataType(type);
125128
}
126-
// TODO cartesian_point, geo_point
127-
throw EsqlIllegalArgumentException.illegalDataType(type);
129+
return SUPPLIERS.get(type).apply(inputChannels);
128130
}
129131
}

‎x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/planner/AggregateMapper.java‎

Lines changed: 12 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -297,25 +297,18 @@ private static String dataTypeToString(DataType type, Class<?> aggClass) {
297297
if (aggClass == Top.class && type.equals(DataType.IP)) {
298298
return "Ip";
299299
}
300-
if (type.equals(DataType.BOOLEAN)) {
301-
return "Boolean";
302-
} else if (type.equals(DataType.INTEGER) || type.equals(DataType.COUNTER_INTEGER)) {
303-
return "Int";
304-
} else if (type.equals(DataType.LONG) || type.equals(DataType.DATETIME) || type.equals(DataType.COUNTER_LONG)) {
305-
return "Long";
306-
} else if (type.equals(DataType.DOUBLE) || type.equals(DataType.COUNTER_DOUBLE)) {
307-
return "Double";
308-
} else if (type.equals(DataType.KEYWORD)
309-
|| type.equals(DataType.IP)
310-
|| type.equals(DataType.VERSION)
311-
|| type.equals(DataType.TEXT)) {
312-
return "BytesRef";
313-
} else if (type.equals(GEO_POINT)) {
314-
return "GeoPoint";
315-
} else if (type.equals(CARTESIAN_POINT)) {
316-
return "CartesianPoint";
317-
} else {
300+
301+
return switch (type) {
302+
case DataType.BOOLEAN -> "Boolean";
303+
case DataType.INTEGER, DataType.COUNTER_INTEGER -> "Int";
304+
case DataType.LONG, DataType.DATETIME, DataType.COUNTER_LONG, DataType.DATE_NANOS -> "Long";
305+
case DataType.DOUBLE, DataType.COUNTER_DOUBLE -> "Double";
306+
case DataType.KEYWORD, DataType.IP, DataType.VERSION, DataType.TEXT -> "BytesRef";
307+
case GEO_POINT -> "GeoPoint";
308+
case CARTESIAN_POINT -> "CartesianPoint";
309+
case SEMANTIC_TEXT, UNSUPPORTED, NULL, UNSIGNED_LONG, SHORT, BYTE, FLOAT, HALF_FLOAT, SCALED_FLOAT, OBJECT, SOURCE, DATE_PERIOD,
310+
TIME_DURATION, CARTESIAN_SHAPE, GEO_SHAPE, DOC_DATA_TYPE, TSID_DATA_TYPE, PARTIAL_AGG ->
318311
throw new EsqlIllegalArgumentException("illegal agg type: " + type.typeName());
319-
}
312+
};
320313
}
321314
}

0 commit comments

Comments
 (0)