Fix float to string casting precision lost with custom FormatNumberFunction

This commit fixes float to string casting by replacing the use of SqlLibraryOperators.FORMAT_NUMBER
with a custom FormatNumberFunction implementation. The new implementation converts the number
to a BigDecimal before formatting to preserve precision and avoid issues like 6.2 becoming
6.199999809265137.

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

Author: yuancu

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

@@ -15,7 +15,6 @@
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.sql.SqlIntervalQualifier;
-import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.SqlTypeName;
@@ -29,17 +28,9 @@
 import org.opensearch.sql.expression.function.PPLBuiltinOperators;
 
 public class ExtendedRexBuilder extends RexBuilder {
-  /**
-   * Formats double values in PPL using a non-scientific notation, displaying up to 16 digits after
-   * the decimal point. This formatting is consistent with PPL V2.
-   */
-  private static final String DOUBLE_FORMAT = "0.0###############";
-
-  private final RexLiteral doubleFormat;
 
   public ExtendedRexBuilder(RexBuilder rexBuilder) {
     super(rexBuilder.getTypeFactory());
-    doubleFormat = makeLiteral(DOUBLE_FORMAT);
   }
 
   public RexNode coalesce(RexNode... nodes) {
@@ -166,7 +157,9 @@ public RexNode makeCast(
     else if (SqlTypeUtil.isApproximateNumeric(exp.getType())
         && SqlTypeUtil.isCharacter(type)
         && format.getType().getSqlTypeName() == SqlTypeName.NULL) {
-      return makeCall(type, SqlLibraryOperators.FORMAT_NUMBER, List.of(exp, doubleFormat));
+      // Use a custom FORMAT_NUMBER which first convert the number to a BigDecimal, then
+      // calls SqlFunctions.formatNumber
+      return makeCall(type, PPLBuiltinOperators.FORMAT_NUMBER, List.of(exp));
     }
     return super.makeCast(pos, type, exp, matchNullability, safe, format);
   }

core/src/main/java/org/opensearch/sql/expression/function/PPLBuiltinOperators.java

@@ -77,6 +77,7 @@
 import org.opensearch.sql.expression.function.udf.math.ConvFunction;
 import org.opensearch.sql.expression.function.udf.math.DivideFunction;
 import org.opensearch.sql.expression.function.udf.math.EulerFunction;
+import org.opensearch.sql.expression.function.udf.math.FormatNumberFunction;
 import org.opensearch.sql.expression.function.udf.math.ModFunction;
 
 /** Defines functions and operators that are implemented only by PPL */
@@ -355,6 +356,7 @@ public class PPLBuiltinOperators extends ReflectiveSqlOperatorTable {
       RELEVANCE_QUERY_FUNCTION_INSTANCE.toUDF("query_string", false);
   public static final SqlOperator MULTI_MATCH =
       RELEVANCE_QUERY_FUNCTION_INSTANCE.toUDF("multi_match", false);
+  public static final SqlOperator FORMAT_NUMBER = new FormatNumberFunction().toUDF("FORMAT_NUMBER");
 
   /**
    * Returns the PPL specific operator table, creating it if necessary.

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

@@ -0,0 +1,70 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.expression.function.udf.math;
+
+import java.math.BigDecimal;
+import java.util.List;
+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.rex.RexCall;
+import org.apache.calcite.runtime.SqlFunctions;
+import org.apache.calcite.sql.type.SqlReturnTypeInference;
+import org.opensearch.sql.calcite.utils.PPLOperandTypes;
+import org.opensearch.sql.calcite.utils.PPLReturnTypes;
+import org.opensearch.sql.expression.function.ImplementorUDF;
+import org.opensearch.sql.expression.function.UDFOperandMetadata;
+
+/**
+ * A custom implementation of FormatNumber in replace of SqlLibraryOperators.FORMAT_NUMBER
+ *
+ * <p>The operators SqlLibraryOperators.FORMAT_NUMBER will convert a float to double with code
+ * equivalent to {@code ((Number) float).doubleValue()}, which will lead to a loss in precision.
+ * E.g. 6.2 becomes 6.199999809265137. This operator fix the problem by converting the number to a
+ * BigDecimal before formatting it.
+ */
+public class FormatNumberFunction extends ImplementorUDF {
+
+  /**
+   * Formats double values in PPL using a non-scientific notation, displaying up to 16 digits after
+   * the decimal point. This formatting is consistent with PPL V2.
+   */
+  private static final String DOUBLE_FORMAT = "0.0###############";
+
+  public FormatNumberFunction() {
+    super(new FormatNumberImplementor(), NullPolicy.ANY);
+  }
+
+  @Override
+  public SqlReturnTypeInference getReturnTypeInference() {
+    return PPLReturnTypes.STRING_FORCE_NULLABLE;
+  }
+
+  @Override
+  public UDFOperandMetadata getOperandMetadata() {
+    return PPLOperandTypes.NUMERIC;
+  }
+
+  public static class FormatNumberImplementor implements NotNullImplementor {
+
+    @Override
+    public Expression implement(
+        RexToLixTranslator translator, RexCall call, List<Expression> translatedOperands) {
+      Expression operand = translatedOperands.get(0);
+      Expression decimal =
+          Expressions.call(
+              FormatNumberImplementor.class, "convertNumber", Expressions.box(operand));
+      return Expressions.call(
+          SqlFunctions.class, "formatNumber", decimal, Expressions.constant(DOUBLE_FORMAT));
+    }
+
+    public static BigDecimal convertNumber(Number number) {
+      return new BigDecimal(number.toString());
+    }
+  }
+}