Cast decimal with NUMBER_TO_STRING function

Signed-off-by: Yuanchun Shen <yuanchu@amazon.com>

Author: yuancu

core/src/main/java/org/opensearch/sql/calcite/ExtendedRexBuilder.java

@@ -105,28 +105,29 @@ public RexNode makeCast(
       boolean safe,
       RexLiteral format) {
     final SqlTypeName sqlType = type.getSqlTypeName();
+    RelDataType sourceType = exp.getType();
     // Calcite bug which doesn't consider to cast literal to boolean
     if (exp instanceof RexLiteral && sqlType == SqlTypeName.BOOLEAN) {
       if (exp.equals(makeLiteral("1", typeFactory.createSqlType(SqlTypeName.CHAR, 1)))) {
         return makeLiteral(true, type);
       } else if (exp.equals(makeLiteral("0", typeFactory.createSqlType(SqlTypeName.CHAR, 1)))) {
         return makeLiteral(false, type);
-      } else if (SqlTypeUtil.isExactNumeric(exp.getType())) {
+      } else if (SqlTypeUtil.isExactNumeric(sourceType)) {
         return makeCall(
             type,
             SqlStdOperatorTable.NOT_EQUALS,
-            ImmutableList.of(exp, makeZeroLiteral(exp.getType())));
+            ImmutableList.of(exp, makeZeroLiteral(sourceType)));
         // TODO https://github.com/opensearch-project/sql/issues/3443
         // Current, we align the behaviour of Spark and Postgres, to align with OpenSearch V2,
         // enable following commented codes.
         //      } else {
         //        return makeCall(type,
         //            SqlStdOperatorTable.NOT_EQUALS,
-        //            ImmutableList.of(exp, makeZeroLiteral(exp.getType())));
+        //            ImmutableList.of(exp, makeZeroLiteral(sourceType)));
       }
     } else if (OpenSearchTypeFactory.isUserDefinedType(type)) {
       var udt = ((AbstractExprRelDataType<?>) type).getUdt();
-      var argExprType = OpenSearchTypeFactory.convertRelDataTypeToExprType(exp.getType());
+      var argExprType = OpenSearchTypeFactory.convertRelDataTypeToExprType(sourceType);
       return switch (udt) {
         case EXPR_DATE -> makeCall(type, PPLBuiltinOperators.DATE, List.of(exp));
         case EXPR_TIME -> makeCall(type, PPLBuiltinOperators.TIME, List.of(exp));
@@ -150,9 +151,10 @@ public RexNode makeCast(
             String.format(Locale.ROOT, "Cannot cast from %s to %s", argExprType, udt.name()));
       };
     }
-    // Use a custom operator when casting an approximate numeric (e.g. double) to a character type.
-    // This patch is necessary because Calcite's built-in CAST converts 0.0 to 0E0 as string.
-    else if (SqlTypeUtil.isApproximateNumeric(exp.getType()) && SqlTypeUtil.isCharacter(type)) {
+    // Use a custom operator when casting floating point or decimal number to a character type.
+    // This patch is necessary because in Calcite, 0.0F is cast to 0E0, decimal 0.x to x
+    else if ((SqlTypeUtil.isApproximateNumeric(sourceType) || SqlTypeUtil.isDecimal(sourceType))
+        && SqlTypeUtil.isCharacter(type)) {
       // NUMBER_TO_STRING uses java's built-in method to get the string representation of a number
       return makeCall(type, PPLBuiltinOperators.NUMBER_TO_STRING, List.of(exp));
     }

core/src/main/java/org/opensearch/sql/expression/function/udf/math/NumberToStringFunction.java

@@ -6,13 +6,11 @@
 package org.opensearch.sql.expression.function.udf.math;
 
 import java.util.List;
-import java.util.Objects;
 import org.apache.calcite.adapter.enumerable.NotNullImplementor;
 import org.apache.calcite.adapter.enumerable.NullPolicy;
 import org.apache.calcite.adapter.enumerable.RexToLixTranslator;
 import org.apache.calcite.linq4j.tree.Expression;
 import org.apache.calcite.linq4j.tree.Expressions;
-import org.apache.calcite.linq4j.tree.Primitive;
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.opensearch.sql.calcite.utils.PPLOperandTypes;
@@ -23,8 +21,8 @@
 /**
  * A custom implementation of number to string cast.
  *
- * <p>This operator is necessary because Calcite's built-in CAST converts 0.0 to 0E0 when casting it
- * to string.
+ * <p>This operator is necessary because Calcite's built-in CAST converts floating point 0.0 to 0E0,
+ * and converts decimal 0.123 to .123 when casting them to string.
  */
 public class NumberToStringFunction extends ImplementorUDF {
   public NumberToStringFunction() {
@@ -47,9 +45,7 @@ public static class NumberToStringImplementor implements NotNullImplementor {
     public Expression implement(
         RexToLixTranslator translator, RexCall call, List<Expression> translatedOperands) {
       Expression operand = translatedOperands.get(0);
-      Primitive primitive = Primitive.of(operand.getType());
-      Objects.requireNonNull(primitive);
-      return Expressions.call(primitive.getBoxClass(), "toString", operand);
+      return Expressions.call(Expressions.box(operand), "toString");
     }
   }
 }