Fix alias type points to nested field

Signed-off-by: Heng Qian <qianheng@amazon.com>

Author: qianheng-aws

integ-test/src/yamlRestTest/resources/rest-api-spec/test/issues/3646.yml

@@ -0,0 +1,67 @@
+setup:
+  - do:
+      indices.create:
+        index: test
+        body:
+          settings:
+            number_of_shards: 1
+            number_of_replicas: 0
+          mappings:
+            properties:
+              log:
+                properties:
+                  url:
+                    properties:
+                      message:
+                        type: text
+                        fields:
+                          keyword:
+                            type: keyword
+                            ignore_above: 256
+                      time:
+                        type: long
+              message_alias:
+                type: alias
+                path: log.url.message
+              time_alias:
+                type: alias
+                path: log.url.time
+
+  - do:
+      query.settings:
+        body:
+          transient:
+            plugins.calcite.enabled : true
+            plugins.calcite.fallback.allowed : false
+
+---
+teardown:
+  - do:
+      query.settings:
+        body:
+          transient:
+            plugins.calcite.enabled : false
+            plugins.calcite.fallback.allowed : true
+
+---
+"Path of alias type points to nested field":
+  - skip:
+      features:
+        - headers
+  - do:
+      bulk:
+        index: test
+        refresh: true
+        body:
+          - '{"index": {}}'
+          - '{"log": {"url": {"message": "/e2e/h/zap", "time": 1} } }'
+
+  - do:
+      headers:
+        Content-Type: 'application/json'
+      ppl:
+        body:
+          query: 'source=test | where message_alias = "/e2e/h/zap" | fields message_alias, time_alias'
+  - match: {"total": 1}
+  - match: {"schema": [{"name": "message_alias", "type": "string"}, {"name": "time_alias", "type": "bigint"}]}
+  - match: {"datarows": [["/e2e/h/zap", 1]]}

opensearch/src/main/java/org/opensearch/sql/opensearch/data/type/OpenSearchDataType.java

@@ -133,15 +133,19 @@ public static Map<String, OpenSearchDataType> parseMapping(Map<String, Object> i
         });
 
     // Begin to parse alias type fields
-    aliasMapping.forEach(
-        (k, v) -> {
-          if (result.containsKey(v)) {
-            result.put(k, new OpenSearchAliasType(v, result.get(v)));
-          } else {
-            throw new IllegalStateException(
-                String.format("Cannot find the path [%s] for alias type field [%s]", v, k));
-          }
-        });
+    if (!aliasMapping.isEmpty()) {
+      // The path of alias type may point to a nested field, so we need to flatten the result.
+      Map<String, OpenSearchDataType> flattenResult = traverseAndFlatten(result);
+      aliasMapping.forEach(
+          (k, v) -> {
+            if (flattenResult.containsKey(v)) {
+              result.put(k, new OpenSearchAliasType(v, flattenResult.get(v)));
+            } else {
+              throw new IllegalStateException(
+                  String.format("Cannot find the path [%s] for alias type field [%s]", v, k));
+            }
+          });
+    }
 
     return result;
   }

opensearch/src/main/java/org/opensearch/sql/opensearch/request/PredicateAnalyzer.java

@@ -1006,17 +1006,21 @@ ExprType getExprType() {
     }
 
     boolean isTextType() {
-      return type != null && type instanceof OpenSearchTextType;
+      return type != null && type.getOriginalExprType() instanceof OpenSearchTextType;
     }
 
     String toKeywordSubField() {
+      ExprType type = this.type.getOriginalExprType();
       if (type instanceof OpenSearchTextType) {
         OpenSearchTextType textType = (OpenSearchTextType) type;
+        // For OpenSearch Alias type which maps to the field of text type,
+        // we have to use its original path
+        String path = this.type.getOriginalPath().orElse(this.name);
         // Find the first subfield with type keyword, return null if non-exist.
         return textType.getFields().entrySet().stream()
             .filter(e -> e.getValue().getMappingType() == MappingType.Keyword)
             .findFirst()
-            .map(e -> name + "." + e.getKey())
+            .map(e -> path + "." + e.getKey())
             .orElse(null);
       }
       return null;

opensearch/src/main/java/org/opensearch/sql/opensearch/storage/scan/CalciteLogicalIndexScan.java

@@ -121,12 +121,17 @@ public CalciteLogicalIndexScan pushDownProject(List<Integer> selectedColumns) {
     }
     RelDataType newSchema = builder.build();
     CalciteLogicalIndexScan newScan = this.copyWithNewSchema(newSchema);
+    Map<String, String> aliasMapping = this.osIndex.getAliasMapping();
+    // For alias types, we need to push down its original path instead of the alias name.
+    List<String> projectedFields =
+        newSchema.getFieldNames().stream()
+            .map(fieldName -> aliasMapping.getOrDefault(fieldName, fieldName))
+            .toList();
     newScan.pushDownContext.add(
         PushDownAction.of(
             PushDownType.PROJECT,
             newSchema.getFieldNames(),
-            requestBuilder ->
-                requestBuilder.pushDownProjectStream(newSchema.getFieldNames().stream())));
+            requestBuilder -> requestBuilder.pushDownProjectStream(projectedFields.stream())));
     return newScan;
   }
 

opensearch/src/main/java/org/opensearch/sql/opensearch/storage/script/filter/lucene/LuceneQuery.java

@@ -109,7 +109,7 @@ public QueryBuilder build(FunctionExpression func) {
     Expression expr = func.getArguments().get(1);
     ExprValue literalValue =
         expr instanceof LiteralExpression ? expr.valueOf() : cast((FunctionExpression) expr, ref);
-    return doBuild(ref.getAttr(), ref.type(), literalValue);
+    return doBuild(ref.getRawPath(), ref.type(), literalValue);
   }
 
   private ExprValue cast(FunctionExpression castFunction, ReferenceExpression ref) {