Fix opaque NullPointerException for unresolvable alias-type field path

When a mapping contains a field of "type": "alias" whose "path" points to
a target absent from the flattened mapping (a text multi-field such as
field.keyword, or a removed/renamed field), validateAliasType passed a null
target into the OpenSearchAliasType constructor, which dereferenced it at
super(type.getExprCoreType()) and surfaced an opaque NullPointerException.

Guard the null target and throw a SemanticCheckException naming the alias
field and its unresolved path. SemanticCheckException extends
QueryEngineException, so JdbcResponseFormatter maps it to HTTP 400 (client
error) rather than the misleading 500 a generic exception would produce.

Add unit tests covering the .keyword multi-field and missing-field cases.

Fixes opensearch-project#5535

Signed-off-by: Jialiang Liang <jiallian@amazon.com>

Author: RyanL1997

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

@@ -16,6 +16,7 @@
 import org.apache.commons.lang3.EnumUtils;
 import org.opensearch.sql.data.type.ExprCoreType;
 import org.opensearch.sql.data.type.ExprType;
+import org.opensearch.sql.exception.SemanticCheckException;
 
 /** The extension of ExprType in OpenSearch. */
 @EqualsAndHashCode
@@ -297,7 +298,17 @@ private static void validateAliasType(Map<String, OpenSearchDataType> result) {
         (key, value) -> {
           if (value instanceof OpenSearchAliasType && value.getOriginalPath().isPresent()) {
             String originalPath = value.getOriginalPath().get();
-            result.put(key, new OpenSearchAliasType(originalPath, result.get(originalPath)));
+            OpenSearchDataType target = result.get(originalPath);
+            if (target == null) {
+              throw new SemanticCheckException(
+                  String.format(
+                      "Alias field [%s] refers to unresolved path [%s]. The alias path must point"
+                          + " to an existing field in the mapping; a text multi-field (e.g."
+                          + " \"%s.keyword\") or a removed/renamed field is not a valid alias"
+                          + " target.",
+                      key, originalPath, originalPath));
+            }
+            result.put(key, new OpenSearchAliasType(originalPath, target));
           }
         });
   }

opensearch/src/test/java/org/opensearch/sql/opensearch/data/type/OpenSearchDataTypeTest.java

@@ -43,6 +43,7 @@
 import org.junit.jupiter.params.provider.MethodSource;
 import org.opensearch.sql.data.type.ExprCoreType;
 import org.opensearch.sql.data.type.ExprType;
+import org.opensearch.sql.exception.SemanticCheckException;
 
 @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
 class OpenSearchDataTypeTest {
@@ -483,6 +484,43 @@ public void test_AliasType() {
         () -> assertEquals("original_path2", aliasTypeOnDouble.getOriginalPath().orElseThrow()));
   }
 
+  @Test
+  public void traverseAndFlatten_alias_to_unresolvable_path_throws_descriptive_error() {
+    // An alias whose path targets a text multi-field (e.g. "source.keyword"). Multi-fields are
+    // stored under OpenSearchTextType.fields, not properties, so they are never added to the
+    // flattened mapping and the alias target resolves to null. Previously this surfaced as an
+    // opaque NullPointerException (issue #5535).
+    Map<String, OpenSearchDataType> keywordAliasTree =
+        Map.of(
+            "source", textKeywordType,
+            "source_alias",
+                new OpenSearchAliasType("source.keyword", OpenSearchDataType.of(MappingType.Invalid)));
+    SemanticCheckException keywordException =
+        assertThrows(
+            SemanticCheckException.class,
+            () -> OpenSearchDataType.traverseAndFlatten(keywordAliasTree));
+    assertEquals(
+        "Alias field [source_alias] refers to unresolved path [source.keyword]. The alias path"
+            + " must point to an existing field in the mapping; a text multi-field (e.g."
+            + " \"source.keyword.keyword\") or a removed/renamed field is not a valid alias target.",
+        keywordException.getMessage());
+
+    // An alias whose path targets a field that does not exist (e.g. renamed/removed).
+    Map<String, OpenSearchDataType> missingFieldTree =
+        Map.of(
+            "col1", textType,
+            "col_alias", new OpenSearchAliasType("missing", OpenSearchDataType.of(MappingType.Invalid)));
+    SemanticCheckException missingException =
+        assertThrows(
+            SemanticCheckException.class,
+            () -> OpenSearchDataType.traverseAndFlatten(missingFieldTree));
+    assertEquals(
+        "Alias field [col_alias] refers to unresolved path [missing]. The alias path must point to"
+            + " an existing field in the mapping; a text multi-field (e.g. \"missing.keyword\") or a"
+            + " removed/renamed field is not a valid alias target.",
+        missingException.getMessage());
+  }
+
   @Test
   public void test_parseMapping_on_AliasType() {
     Map<String, Object> indexMapping1 =