ES|QL: Allow nested MapExpressions (elastic#133311)

Author: ioanatia

x-pack/plugin/esql/src/main/antlr/parser/Expression.g4

@@ -63,7 +63,12 @@ mapExpression
     ;
 
 entryExpression
-    : key=string COLON value=constant
+    : key=string COLON value=mapValue
+    ;
+
+mapValue
+    : constant
+    | mapExpression
     ;
 
 constant

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

@@ -78,18 +78,26 @@ public static void populateMap(
         for (EntryExpression entry : options.entryExpressions()) {
             Expression optionExpr = entry.key();
             Expression valueExpr = entry.value();
-            Expression.TypeResolution resolution = isFoldable(optionExpr, source.text(), paramOrdinal).and(
-                isFoldable(valueExpr, source.text(), paramOrdinal)
-            );
-            if (resolution.unresolved()) {
-                throw new InvalidArgumentException(resolution.message());
+
+            Expression.TypeResolution optionNameResolution = isFoldable(optionExpr, source.text(), paramOrdinal);
+            if (optionNameResolution.unresolved()) {
+                throw new InvalidArgumentException(optionNameResolution.message());
             }
+
             Object optionExprLiteral = ((Literal) optionExpr).value();
-            Object valueExprLiteral = ((Literal) valueExpr).value();
             String optionName = optionExprLiteral instanceof BytesRef br ? br.utf8ToString() : optionExprLiteral.toString();
+            DataType dataType = allowedOptions.get(optionName);
+
+            // valueExpr could be a MapExpression, but for now functions only accept literal values in options
+            if ((valueExpr instanceof Literal) == false) {
+                throw new InvalidArgumentException(
+                    format(null, "Invalid option [{}] in [{}], expected a [{}] value", optionName, source.text(), dataType)
+                );
+            }
+
+            Object valueExprLiteral = ((Literal) valueExpr).value();
             String optionValue = valueExprLiteral instanceof BytesRef br ? br.utf8ToString() : valueExprLiteral.toString();
             // validate the optionExpr is supported
-            DataType dataType = allowedOptions.get(optionName);
             if (dataType == null) {
                 throw new InvalidArgumentException(
                     format(null, "Invalid option [{}] in [{}], expected one of {}", optionName, source.text(), allowedOptions.keySet())

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

@@ -10,7 +10,6 @@
 import org.elasticsearch.common.io.stream.StreamOutput;
 import org.elasticsearch.common.lucene.BytesRefs;
 import org.elasticsearch.compute.operator.EvalOperator;
-import org.elasticsearch.xpack.esql.core.expression.EntryExpression;
 import org.elasticsearch.xpack.esql.core.expression.Expression;
 import org.elasticsearch.xpack.esql.core.expression.Literal;
 import org.elasticsearch.xpack.esql.core.expression.MapExpression;
@@ -22,6 +21,7 @@
 import org.elasticsearch.xpack.esql.expression.function.FunctionInfo;
 import org.elasticsearch.xpack.esql.expression.function.MapParam;
 import org.elasticsearch.xpack.esql.expression.function.OptionalArgument;
+import org.elasticsearch.xpack.esql.expression.function.Options;
 import org.elasticsearch.xpack.esql.expression.function.Param;
 import org.elasticsearch.xpack.esql.expression.function.scalar.EsqlScalarFunction;
 
@@ -31,7 +31,6 @@
 import java.util.Set;
 
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.ParamOrdinal.SECOND;
-import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isMapExpression;
 import static org.elasticsearch.xpack.esql.core.expression.TypeResolutions.isTypeOrUnionType;
 import static org.elasticsearch.xpack.esql.core.type.DataType.IP;
 import static org.elasticsearch.xpack.esql.core.type.DataType.KEYWORD;
@@ -173,39 +172,11 @@ protected TypeResolution resolveType() {
             sourceText(),
             null,
             supportedTypesNames(supportedTypes())
-        );
-        if (resolution.unresolved()) {
-            return resolution;
-        }
-        if (options == null) {
-            return resolution;
-        }
-        resolution = isMapExpression(options, sourceText(), SECOND);
+        ).and(Options.resolve(options, source(), SECOND, ALLOWED_OPTIONS));
+
         if (resolution.unresolved()) {
             return resolution;
         }
-        for (EntryExpression e : ((MapExpression) options).entryExpressions()) {
-            String key;
-            if (e.key().dataType() != KEYWORD) {
-                return new TypeResolution("map keys must be strings");
-            }
-            if (e.key() instanceof Literal keyl) {
-                key = BytesRefs.toString(keyl.value());
-            } else {
-                return new TypeResolution("map keys must be literals");
-            }
-            DataType expected = ALLOWED_OPTIONS.get(key);
-            if (expected == null) {
-                return new TypeResolution("[" + key + "] is not a supported option");
-            }
-
-            if (e.value().dataType() != expected) {
-                return new TypeResolution("[" + key + "] expects [" + expected + "] but was [" + e.value().dataType() + "]");
-            }
-            if (e.value() instanceof Literal == false) {
-                return new TypeResolution("map values must be literals");
-            }
-        }
         try {
             LeadingZeros.from((MapExpression) options);
         } catch (IllegalArgumentException e) {