Add support for ±Infinity and NaN in NUMBER

Extend `NUMBER` type to allow representing positive/negative
infinity and not-a-number values.

This will allow e.g. the following:

- safely convert all values of `real` and `double` to `number`
- read PostgreSQL's `decimal` values (PostgreSQL `decimal` can hold
  infinity, and the unconstrained decimal (with dynamic scale) can also
  hold not-a-number)

Author: findepi

client/trino-client/src/main/java/io/trino/client/JsonDecodingUtils.java

@@ -272,7 +272,22 @@ private static class NumberDecoder
         public Object decode(JsonParser parser)
                 throws IOException
         {
-            return new BigDecimal(parser.getValueAsString());
+            String value = parser.getValueAsString();
+            // There is no JDK builtin numeric class that can represent all NUMBER values losslessly.
+            // Return finite values as BigDecimal and non-finite values as Double.
+            // Alternative approach could be to introduce a Trino-specific type to hold these values,
+            // but that would not be friendly for JDBC-based apps, which often are compiled against
+            // just the JDBC interfaces.
+            switch (value) {
+                case "NaN":
+                    return Double.NaN;
+                case "+Infinity":
+                    return Double.POSITIVE_INFINITY;
+                case "-Infinity":
+                    return Double.NEGATIVE_INFINITY;
+                default:
+                    return new BigDecimal(value);
+            }
         }
     }
 

core/trino-main/src/main/java/io/trino/operator/JoinDomainBuilder.java

@@ -43,6 +43,7 @@
 import static io.trino.spi.function.InvocationConvention.simpleConvention;
 import static io.trino.spi.predicate.Range.range;
 import static io.trino.spi.type.DoubleType.DOUBLE;
+import static io.trino.spi.type.NumberType.NUMBER;
 import static io.trino.spi.type.RealType.REAL;
 import static io.trino.spi.type.TypeUtils.isFloatingPointNaN;
 import static io.trino.spi.type.TypeUtils.readNativeValue;
@@ -113,8 +114,8 @@ public JoinDomainBuilder(
         this.maxFilterSizeInBytes = maxFilterSize.toBytes();
         this.notifyStateChange = requireNonNull(notifyStateChange, "notifyStateChange is null");
 
-        // Skipping DOUBLE and REAL in collectMinMaxValues to avoid dealing with NaN values
-        this.collectMinMax = minMaxEnabled && type.isOrderable() && type != DOUBLE && type != REAL;
+        // Skipping REAL, DOUBLE and NUMBER in collectMinMaxValues to avoid dealing with NaN values
+        this.collectMinMax = minMaxEnabled && type.isOrderable() && type != REAL && type != DOUBLE && type != NUMBER;
 
         MethodHandle readOperator = typeOperators.getReadValueOperator(type, simpleConvention(NULLABLE_RETURN, FLAT));
         readOperator = readOperator.asType(readOperator.type().changeReturnType(Object.class));

core/trino-main/src/main/java/io/trino/sql/planner/DomainTranslator.java

@@ -400,7 +400,7 @@ protected ExtractionResult visitLogical(Logical node, Boolean complement)
                             remainingExpression = residuals.get(0);
                         }
                         else if (matchingSingleSymbolDomains) {
-                            // Types REAL and DOUBLE require special handling because they include NaN value. In this case, we cannot rely on the union of domains.
+                            // Types REAL, DOUBLE and NUMBER require special handling because they include NaN value. In this case, we cannot rely on the union of domains.
                             // That is because domains covering the value set partially might union up to a domain covering the whole value set.
                             // While the component domains didn't include NaN, the resulting domain could be further translated to predicate "TRUE" or "a IS NOT NULL",
                             // which is satisfied by NaN. So during domain union, NaN might be implicitly added.

core/trino-main/src/main/java/io/trino/testing/MaterializedResult.java

@@ -32,6 +32,7 @@
 import io.trino.spi.type.SqlTimeWithTimeZone;
 import io.trino.spi.type.SqlTimestamp;
 import io.trino.spi.type.SqlTimestampWithTimeZone;
+import io.trino.spi.type.TrinoNumber;
 import io.trino.spi.type.Type;
 
 import java.math.BigDecimal;
@@ -324,7 +325,11 @@ private static MaterializedRow convertToTestTypes(MaterializedRow trinoRow)
                 case SqlTimestamp sqlTimestamp -> sqlTimestamp.toLocalDateTime();
                 case SqlTimestampWithTimeZone sqlTimestampWithTimeZone -> sqlTimestampWithTimeZone.toZonedDateTime();
                 case SqlDecimal sqlDecimal -> sqlDecimal.toBigDecimal();
-                case SqlNumber sqlNumber -> new BigDecimal(sqlNumber.stringified());
+                case SqlNumber number -> switch (number.value()) {
+                    case TrinoNumber.NotANumber() -> Double.NaN;
+                    case TrinoNumber.Infinity(boolean negative) -> negative ? Double.NEGATIVE_INFINITY : Double.POSITIVE_INFINITY;
+                    case TrinoNumber.BigDecimalValue(BigDecimal bigDecimal) -> bigDecimal;
+                };
                 default -> trinoValue;
             };
             convertedValues.add(convertedValue);

core/trino-main/src/main/java/io/trino/type/DecimalCasts.java

@@ -39,6 +39,7 @@
 
 import java.io.IOException;
 import java.math.BigDecimal;
+import java.util.Optional;
 
 import static io.airlift.slice.Slices.utf8Slice;
 import static io.trino.spi.StandardErrorCode.INVALID_CAST_ARGUMENT;
@@ -498,7 +499,8 @@ public static TrinoNumber longDecimalToNumber(Int128 decimal, long precision, lo
     @UsedByGeneratedCode
     public static long numberToShortDecimal(TrinoNumber value, long precision, long scale, long tenToScale)
     {
-        BigDecimal bigDecimal = value.toBigDecimal();
+        BigDecimal bigDecimal = numberToBigDecimal(value)
+                .orElseThrow(() -> new TrinoException(INVALID_CAST_ARGUMENT, format("Cannot cast NUMBER '%s' to DECIMAL(%s, %s)", value, precision, scale)));
         BigDecimal result;
         try {
             result = bigDecimal.setScale(DecimalConversions.intScale(scale), HALF_UP);
@@ -517,7 +519,8 @@ public static long numberToShortDecimal(TrinoNumber value, long precision, long
     @UsedByGeneratedCode
     public static Int128 numberToLongDecimal(TrinoNumber value, long precision, long scale, Int128 tenToScale)
     {
-        BigDecimal bigDecimal = value.toBigDecimal();
+        BigDecimal bigDecimal = numberToBigDecimal(value)
+                .orElseThrow(() -> new TrinoException(INVALID_CAST_ARGUMENT, format("Cannot cast NUMBER '%s' to DECIMAL(%s, %s)", value, precision, scale)));
         BigDecimal result;
         try {
             result = bigDecimal.setScale(DecimalConversions.intScale(scale), HALF_UP);
@@ -533,6 +536,14 @@ public static Int128 numberToLongDecimal(TrinoNumber value, long precision, long
         return Int128.valueOf(result.unscaledValue());
     }
 
+    private static Optional<BigDecimal> numberToBigDecimal(TrinoNumber value)
+    {
+        return switch (value.toBigDecimal()) {
+            case TrinoNumber.NotANumber _, TrinoNumber.Infinity _ -> Optional.empty();
+            case TrinoNumber.BigDecimalValue(BigDecimal bigDecimal) -> Optional.of(bigDecimal);
+        };
+    }
+
     @UsedByGeneratedCode
     public static Slice shortDecimalToVarchar(long decimal, long scale, long varcharLength)
     {

core/trino-main/src/main/java/io/trino/type/DoubleOperators.java

@@ -24,7 +24,9 @@
 import io.trino.spi.function.ScalarOperator;
 import io.trino.spi.function.SqlType;
 import io.trino.spi.type.StandardTypes;
+import io.trino.spi.type.TrinoNumber;
 
+import java.math.BigDecimal;
 import java.text.DecimalFormat;
 import java.text.DecimalFormatSymbols;
 
@@ -174,6 +176,19 @@ public static long castToReal(@SqlType(StandardTypes.DOUBLE) double value)
         return floatToRawIntBits((float) value);
     }
 
+    @ScalarOperator(CAST)
+    @SqlType(StandardTypes.NUMBER)
+    public static TrinoNumber castToNumber(@SqlType(StandardTypes.DOUBLE) double value)
+    {
+        if (Double.isNaN(value)) {
+            return TrinoNumber.from(new TrinoNumber.NotANumber());
+        }
+        if (Double.isInfinite(value)) {
+            return TrinoNumber.from(new TrinoNumber.Infinity(value < 0.0));
+        }
+        return TrinoNumber.from(BigDecimal.valueOf(value));
+    }
+
     @ScalarOperator(CAST)
     @LiteralParameters("x")
     @SqlType("varchar(x)")