[CALCITE-6066] Add HYPOT function (enabled in Spark library)

core/src/main/java/org/apache/calcite/runtime/CalciteResource.java

@@ -1075,7 +1075,4 @@ ExInst<RuntimeException> multipleCapturingGroupsForRegexpExtract(String value,
 
   @BaseMessage("BIT_GET/GETBIT error: position {0,number} exceeds the bit upper limit {1,number}")
   ExInst<CalciteException> illegalBitGetPositionExceedsLimit(int position, int size);
-
-  @BaseMessage("Argument to function ''{0}'' must be a positive number, but given value is ''{1}''")
-  ExInst<CalciteException> argumentMustBePositiveNumber(String a0, String a1);
 }

core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java

@@ -3041,22 +3041,13 @@ public static double degrees(double b0) {
     return Math.toDegrees(b0);
   }
 
-  public static double hypot(long a, long b) {
-    return hypot(Double.valueOf(a), Double.valueOf(b));
-  }
-
-  public static double hypot(long a, double b) {
-    return hypot(Double.valueOf(a), b);
-  }
-
-  public static double hypot(double a, long b) {
-    return hypot(a, Double.valueOf(b));
+  /** SQL <code>HYPOT</code> operator applied to BigDecimal values. */
+  public static double hypot(BigDecimal a, BigDecimal b) {
+    return hypot(a.doubleValue(), b.doubleValue());
   }
 
+  /** SQL <code>HYPOT</code> operator applied to double values. */
   public static double hypot(double a, double b) {
-    if (a <= 0 || b <= 0) {
-      throw RESOURCE.argumentMustBePositiveNumber("HYPOT", String.valueOf(a < 0 ? a : b)).ex();
-    }
     return Math.hypot(a, b);
   }
 

core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java

@@ -1972,10 +1972,9 @@ private static RelDataType deriveTypeMapFromEntries(SqlOperatorBinding opBinding
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
-  /** The {@code HYPOT(numeric1, numeric2)} function; returns the hypotenuse
-   * of a right-angle triangle with two right-angle sides of {@code numeric1}
-   * and {@code numeric2}. */
-  @LibraryOperator(libraries = {SPARK, ORACLE})
+  /** The {@code HYPOT(numeric1, numeric2)} function; returns
+   * sqrt(numeric1^2+ numeric2^2) without intermediate overflow or underflow. */
+  @LibraryOperator(libraries = {SPARK})
   public static final SqlFunction HYPOT =
       SqlBasicFunction.create("HYPOT",
           ReturnTypes.DOUBLE_NULLABLE,

core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties

@@ -351,5 +351,4 @@ MultipleRowSemanticsTables=A table function at most has one input table with row
 NoOperator=No operator for ''{0}'' with kind: ''{1}'', syntax: ''{2}'' during JSON deserialization
 IllegalNegativeBitGetPosition=BIT_GET/GETBIT error: negative position {0,number} not allowed
 IllegalBitGetPositionExceedsLimit=BIT_GET/GETBIT error: position {0,number} exceeds the bit upper limit {1,number}
-ArgumentMustBePositiveNumber=Argument to function ''{0}'' must be a positive number, but given value is ''{1}''
 # End CalciteResource.properties

site/_docs/reference.md

@@ -2739,7 +2739,7 @@ BigQuery's type system uses confusingly different names for types and functions:
 | b | FORMAT_TIMESTAMP(string timestamp)             | Formats *timestamp* according to the specified format *string*
 | s | GETBIT(value, position)                        | Equivalent to `BIT_GET(value, position)`
 | b o | GREATEST(expr [, expr ]*)                    | Returns the greatest of the expressions
-| s o | HYPOT(numeric1, numeric2)                    | Returns the hypotenuse of a right-angle triangle with two right-angle sides of *numeric1* and *numeric2*
+| s | HYPOT(numeric1, numeric2)                      | Returns sqrt(*numeric1*^2+ *numeric2*^2) without intermediate overflow or underflow
 | b h s | IF(condition, value1, value2)              | Returns *value1* if *condition* is TRUE, *value2* otherwise
 | b | IFNULL(value1, value2)                         | Equivalent to `NVL(value1, value2)`
 | p | string1 ILIKE string2 [ ESCAPE string3 ]       | Whether *string1* matches pattern *string2*, ignoring case (similar to `LIKE`)

testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java

@@ -7475,17 +7475,25 @@ private static void checkIf(SqlOperatorFixture f) {
     f0.checkFails("^hypot(3, 4)^",
         "No match found for function signature HYPOT\\(<NUMERIC>, <NUMERIC>\\)",
         false);
-    final Consumer<SqlOperatorFixture> consumer = f -> {
-      f.checkType("hypot(3, 4)", "DOUBLE NOT NULL");
-      f.checkScalarApprox("hypot(3, 4)", "DOUBLE NOT NULL",
-          isWithin(5.0000d, 0.0001d));
-      f.checkScalarApprox("hypot(2, 4)", "DOUBLE NOT NULL",
-          isWithin(4.4721d, 0.0001d));
-      f.checkNull("hypot(cast(null as bigint), 1)");
-      f.checkNull("hypot(cast(null as bigint), cast(null as bigint))");
-      f.checkNull("hypot(cast(null as double), cast(null as double))");
-    };
-    f0.forEachLibrary(list(SqlLibrary.SPARK, SqlLibrary.ORACLE), consumer);
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.SPARK);
+    f.checkScalarApprox("hypot(3, 4)", "DOUBLE NOT NULL",
+        isWithin(5.0000d, 0.0001d));
+    f.checkScalarApprox("hypot(3.0, cast(4 as bigint))", "DOUBLE NOT NULL",
+        isWithin(5.0000d, 0.0001d));
+    f.checkScalarApprox("hypot(cast(-2 as bigint), cast(-4 as bigint))",
+        "DOUBLE NOT NULL",
+        isWithin(4.4721d, 0.0001d));
+    f.checkScalarApprox("hypot(cast(3.0 as double), cast(4.0 as double))",
+        "DOUBLE NOT NULL",
+        isWithin(5.0000d, 0.0001d));
+    f.checkScalarApprox("hypot(-2.5, cast(-4.5 as double))", "DOUBLE NOT NULL",
+        isWithin(5.1478d, 0.0001d));
+    f.checkScalarApprox("hypot(-2.5, -4.5)", "DOUBLE NOT NULL",
+        isWithin(5.1478d, 0.0001d));
+    f.checkNull("hypot(cast(null as bigint), 1)");
+    f.checkNull("hypot(cast(null as bigint), cast(null as bigint))");
+    f.checkNull("hypot(cast(null as double), cast(null as double))");
+    f.checkNull("hypot(cast(null as decimal), cast(null as decimal))");
   }
 
   @Test void testInfinity() {