Fix issue 3339

Signed-off-by: Peng Huo <penghuo@gmail.com>

Author: penghuo

integ-test/src/test/java/org/opensearch/sql/ppl/DataTypeIT.java

@@ -32,10 +32,10 @@ public void test_numeric_data_types() throws IOException {
     JSONObject result = executeQuery(String.format("source=%s", TEST_INDEX_DATATYPE_NUMERIC));
     verifySchema(
         result,
-        schema("long_number", "long"),
-        schema("integer_number", "integer"),
-        schema("short_number", "short"),
-        schema("byte_number", "byte"),
+        schema("long_number", "bigint"),
+        schema("integer_number", "int"),
+        schema("short_number", "smallint"),
+        schema("byte_number", "tinyint"),
         schema("double_number", "double"),
         schema("float_number", "float"),
         schema("half_float_number", "float"),
@@ -73,10 +73,10 @@ public void test_long_integer_data_type() throws IOException {
                 TEST_INDEX_DATATYPE_NUMERIC));
     verifySchema(
         result,
-        schema("int1", "integer"),
-        schema("int2", "integer"),
-        schema("long1", "long"),
-        schema("long2", "long"));
+        schema("int1", "int"),
+        schema("int2", "int"),
+        schema("long1", "bigint"),
+        schema("long2", "bigint"));
   }
 
   @Test
@@ -86,6 +86,6 @@ public void test_alias_data_type() throws IOException {
             String.format(
                 "source=%s | where alias_col > 1 " + "| fields original_col, alias_col ",
                 TEST_INDEX_ALIAS));
-    verifySchema(result, schema("original_col", "integer"), schema("alias_col", "integer"));
+    verifySchema(result, schema("original_col", "int"), schema("alias_col", "int"));
   }
 }

plugin/src/main/java/org/opensearch/sql/plugin/transport/TransportPPLQueryAction.java

@@ -33,6 +33,7 @@
 import org.opensearch.sql.ppl.PPLService;
 import org.opensearch.sql.ppl.domain.PPLQueryRequest;
 import org.opensearch.sql.protocol.response.QueryResult;
+import org.opensearch.sql.protocol.response.datatype.PPLResponseDataType;
 import org.opensearch.sql.protocol.response.format.CsvResponseFormatter;
 import org.opensearch.sql.protocol.response.format.Format;
 import org.opensearch.sql.protocol.response.format.JsonResponseFormatter;
@@ -160,7 +161,8 @@ private ResponseListener<ExecutionEngine.QueryResponse> createListener(
       public void onResponse(ExecutionEngine.QueryResponse response) {
         String responseContent =
             formatter.format(
-                new QueryResult(response.getSchema(), response.getResults(), response.getCursor()));
+                new QueryResult(response.getSchema(), response.getResults(), response.getCursor()
+                    , PPLResponseDataType.getInstance()));
         listener.onResponse(new TransportPPLQueryResponse(responseContent));
       }
 

protocol/src/main/java/org/opensearch/sql/protocol/response/QueryResult.java

@@ -17,12 +17,12 @@
 import org.opensearch.sql.executor.ExecutionEngine;
 import org.opensearch.sql.executor.ExecutionEngine.Schema.Column;
 import org.opensearch.sql.executor.pagination.Cursor;
+import org.opensearch.sql.protocol.response.datatype.ResponseDataType;
 
 /**
  * Query response that encapsulates query results and isolate {@link ExprValue} related from
  * formatter implementation.
  */
-@RequiredArgsConstructor
 public class QueryResult implements Iterable<Object[]> {
 
   @Getter private final ExecutionEngine.Schema schema;
@@ -32,8 +32,23 @@ public class QueryResult implements Iterable<Object[]> {
 
   @Getter private final Cursor cursor;
 
+  private final ResponseDataType responseDataType;
+
   public QueryResult(ExecutionEngine.Schema schema, Collection<ExprValue> exprValues) {
-    this(schema, exprValues, Cursor.None);
+    this(schema, exprValues, Cursor.None, ResponseDataType.DEFAULT);
+  }
+
+  public QueryResult(ExecutionEngine.Schema schema, Collection<ExprValue> exprValues, Cursor cursor) {
+    this(schema, exprValues, cursor, ResponseDataType.DEFAULT);
+  }
+
+  public QueryResult(ExecutionEngine.Schema schema, Collection<ExprValue> exprValues,
+                     Cursor cursor,
+                     ResponseDataType responseDataType) {
+    this.schema = schema;
+    this.exprValues = exprValues;
+    this.cursor = cursor;
+    this.responseDataType = responseDataType;
   }
 
   /**
@@ -59,7 +74,7 @@ public Map<String, String> columnNameTypes() {
             column ->
                 colNameTypes.put(
                     getColumnName(column),
-                    column.getExprType().typeName().toLowerCase(Locale.ROOT)));
+                    responseDataType.typeName(column.getExprType()).toLowerCase(Locale.ROOT)));
     return colNameTypes;
   }
 

protocol/src/main/java/org/opensearch/sql/protocol/response/datatype/PPLResponseDataType.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.protocol.response.datatype;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.opensearch.sql.data.type.ExprCoreType;
+import org.opensearch.sql.data.type.ExprType;
+
+/**
+ * Singleton implementation of {@code ResponseDataType} for PPL.
+ * <p>
+ * This class maps expression types to their corresponding PPL types.
+ * The mapping includes BYTE to "tinyint", SHORT to "smallint",
+ * INTEGER to "int", and LONG to "bigint".
+ * </p>
+ */
+public class PPLResponseDataType implements ResponseDataType{
+
+  private static final PPLResponseDataType INSTANCE = new PPLResponseDataType();
+
+  private static Map<ExprType, String> exprTypeToPPLType = new HashMap<>();
+
+  static {
+    exprTypeToPPLType.put(ExprCoreType.BYTE, "tinyint");
+    exprTypeToPPLType.put(ExprCoreType.SHORT, "smallint");
+    exprTypeToPPLType.put(ExprCoreType.INTEGER, "int");
+    exprTypeToPPLType.put(ExprCoreType.LONG, "bigint");
+  }
+
+  private PPLResponseDataType() {}
+
+  public static PPLResponseDataType getInstance() {
+    return INSTANCE;
+  }
+
+  /**
+   * Returns the corresponding PPL type name for the given expression type.
+   * If the expression type is not mapped, it returns the default type name.
+   *
+   * @param exprType the expression type.
+   * @return the PPL type name associated with the expression type, or the default type name.
+   */
+  @Override
+  public String typeName(ExprType exprType) {
+    return exprTypeToPPLType.getOrDefault(exprType, exprType.typeName());
+  }
+}

protocol/src/main/java/org/opensearch/sql/protocol/response/datatype/ResponseDataType.java

@@ -0,0 +1,17 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.protocol.response.datatype;
+
+import org.opensearch.sql.data.type.ExprType;
+
+public interface ResponseDataType {
+
+  ResponseDataType DEFAULT = new ResponseDataType() {};
+
+  default String typeName(ExprType exprType) {
+    return exprType.typeName();
+  }
+}

protocol/src/test/java/org/opensearch/sql/protocol/response/datatype/PPLResponseDataTypeTest.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.protocol.response.datatype;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+import org.junit.jupiter.api.Test;
+import org.opensearch.sql.data.type.ExprCoreType;
+import org.opensearch.sql.data.type.ExprType;
+
+class PPLResponseDataTypeTest {
+  /**
+   * Tests that the same instance is returned from the singleton.
+   */
+  @Test
+  public void testSingletonInstance() {
+    PPLResponseDataType instance1 = PPLResponseDataType.getInstance();
+    PPLResponseDataType instance2 = PPLResponseDataType.getInstance();
+    assertSame(instance1, instance2, "Expected both instances to be the same (singleton).");
+  }
+
+  /**
+   * Tests that known expression types return the correct PPL type names.
+   */
+  @Test
+  public void testTypeNameMapping() {
+    PPLResponseDataType instance = PPLResponseDataType.getInstance();
+    assertEquals("tinyint", instance.typeName(ExprCoreType.BYTE), "BYTE should map to tinyint.");
+    assertEquals("smallint", instance.typeName(ExprCoreType.SHORT), "SHORT should map to smallint.");
+    assertEquals("int", instance.typeName(ExprCoreType.INTEGER), "INTEGER should map to int.");
+    assertEquals("bigint", instance.typeName(ExprCoreType.LONG), "LONG should map to bigint.");
+  }
+
+  /**
+   * Tests that an unmapped expression type returns its default type name.
+   */
+  @Test
+  public void testTypeNameDefault() {
+    PPLResponseDataType instance = PPLResponseDataType.getInstance();
+
+    // Create a dummy expression type not in the mapping.
+    ExprType dummyExprType = new ExprType() {
+      @Override
+      public String typeName() {
+        return "defaultType";
+      }
+    };
+
+    assertEquals("defaultType", instance.typeName(dummyExprType),
+        "Unmapped expression type should return its default type name.");
+  }
+}