[CALCITE-6224] Add LOG2 function (enabled in MySQL, Spark library)
Co-authored-by: Tanner Clary <tannerclary@google.com>
close #3707
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
index 220d33f..bc76a59 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
@@ -208,6 +208,7 @@
import static org.apache.calcite.sql.fun.SqlLibraryOperators.LEFT;
import static org.apache.calcite.sql.fun.SqlLibraryOperators.LEVENSHTEIN;
import static org.apache.calcite.sql.fun.SqlLibraryOperators.LOG;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.LOG2;
import static org.apache.calcite.sql.fun.SqlLibraryOperators.LOGICAL_AND;
import static org.apache.calcite.sql.fun.SqlLibraryOperators.LOGICAL_OR;
import static org.apache.calcite.sql.fun.SqlLibraryOperators.LPAD;
@@ -637,6 +638,7 @@
defineMethod(EXP, BuiltInMethod.EXP.method, NullPolicy.STRICT);
defineMethod(POWER, BuiltInMethod.POWER.method, NullPolicy.STRICT);
defineMethod(ABS, BuiltInMethod.ABS.method, NullPolicy.STRICT);
+ defineMethod(LOG2, BuiltInMethod.LOG2.method, NullPolicy.STRICT);
map.put(LN, new LogImplementor());
map.put(LOG, new LogImplementor());
diff --git a/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
index 6e9a294..7ba962e 100644
--- a/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -2764,7 +2764,7 @@
}
- // LN, LOG, LOG10
+ // LN, LOG, LOG10, LOG2
/** SQL {@code LOG(number, number2)} function applied to double values. */
public static double log(double d0, double d1) {
@@ -2788,6 +2788,17 @@
return Math.log(d0.doubleValue()) / Math.log(d1.doubleValue());
}
+ /** SQL {@code LOG2(number)} function applied to double values. */
+ public static @Nullable Double log2(double number) {
+ return (number <= 0) ? null : log(number, 2);
+ }
+
+ /** SQL {@code LOG2(number)} function applied to
+ * BigDecimal values. */
+ public static @Nullable Double log2(BigDecimal number) {
+ return log2(number.doubleValue());
+ }
+
// MOD
/** SQL <code>MOD</code> operator applied to byte values. */
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java
index 1fc6524..86a72d2 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperators.java
@@ -2149,6 +2149,14 @@
OperandTypes.NUMERIC_OPTIONAL_NUMERIC,
SqlFunctionCategory.NUMERIC);
+ /** The "LOG2(numeric)" function. Returns the base 2 logarithm of numeric. */
+ @LibraryOperator(libraries = {MYSQL, SPARK})
+ public static final SqlFunction LOG2 =
+ SqlBasicFunction.create("LOG2",
+ ReturnTypes.DOUBLE_FORCE_NULLABLE,
+ OperandTypes.NUMERIC,
+ SqlFunctionCategory.NUMERIC);
+
@LibraryOperator(libraries = {BIG_QUERY, SPARK})
public static final SqlFunction POW =
SqlStdOperatorTable.POWER.withName("POW");
diff --git a/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java b/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
index fd46977..13e6807 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
@@ -397,6 +397,13 @@
DOUBLE.andThen(SqlTypeTransforms.TO_NULLABLE);
/**
+ * Type-inference strategy whereby the result type of a call is a nullable
+ * Double.
+ */
+ public static final SqlReturnTypeInference DOUBLE_FORCE_NULLABLE =
+ DOUBLE.andThen(SqlTypeTransforms.FORCE_NULLABLE);
+
+ /**
* Type-inference strategy whereby the result type of a call is a Char.
*/
public static final SqlReturnTypeInference CHAR =
diff --git a/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java b/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
index 4ac9596..b98cc91 100644
--- a/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
+++ b/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
@@ -510,6 +510,7 @@
SAFE_MULTIPLY(SqlFunctions.class, "safeMultiply", double.class, double.class),
SAFE_SUBTRACT(SqlFunctions.class, "safeSubtract", double.class, double.class),
LOG(SqlFunctions.class, "log", long.class, long.class),
+ LOG2(SqlFunctions.class, "log2", long.class),
SEC(SqlFunctions.class, "sec", double.class),
SECH(SqlFunctions.class, "sech", double.class),
SIGN(SqlFunctions.class, "sign", long.class),
diff --git a/site/_docs/reference.md b/site/_docs/reference.md
index 585ebd1..ed697a9 100644
--- a/site/_docs/reference.md
+++ b/site/_docs/reference.md
@@ -2783,6 +2783,7 @@
| b f s | LENGTH(string) | Equivalent to `CHAR_LENGTH(string)`
| h s | LEVENSHTEIN(string1, string2) | Returns the Levenshtein distance between *string1* and *string2*
| b | LOG(numeric1 [, numeric2 ]) | Returns the logarithm of *numeric1* to base *numeric2*, or base e if *numeric2* is not present
+| m s | LOG2(numeric) | Returns the base 2 logarithm of *numeric*
| b o s | LPAD(string, length [, pattern ]) | Returns a string or bytes value that consists of *string* prepended to *length* with *pattern*
| b | TO_BASE32(string) | Converts the *string* to base-32 encoded form and returns an encoded string
| b | FROM_BASE32(string) | Returns the decoded result of a base-32 *string* as a string
diff --git a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
index 11cc788..0ca4b26 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
@@ -6243,6 +6243,43 @@
f.checkNull("log(10, cast(null as real))");
}
+ /** Test case for
+ * <a href="https://issues.apache.org/jira/browse/CALCITE-6224">[CALCITE-6224]
+ * Add LOG2 function (enabled in MYSQL, Spark library)</a>. */
+ @Test void testLog2Func() {
+ final SqlOperatorFixture f0 = fixture();
+ f0.checkFails("^log2(4)^",
+ "No match found for function signature LOG2\\(<NUMERIC>\\)", false);
+ f0.setFor(SqlLibraryOperators.LOG2);
+ final Consumer<SqlOperatorFixture> consumer = f -> {
+ f.checkScalarApprox("log2(2)", "DOUBLE",
+ isWithin(1.0, 0.000001));
+ f.checkScalarApprox("log2(4)", "DOUBLE",
+ isWithin(2.0, 0.000001));
+ f.checkScalarApprox("log2(65536)", "DOUBLE",
+ isWithin(16.0, 0.000001));
+ f.checkScalarApprox("log2(2.0/3)", "DOUBLE",
+ isWithin(-0.5849625007211561, 0.000001));
+ f.checkScalarApprox("log2(4.0/3)", "DOUBLE",
+ isWithin(0.4150374992788435, 0.000001));
+ f.checkScalarApprox("log2(0.5)", "DOUBLE",
+ isWithin(-1.0, 0.000001));
+ f.checkScalarApprox("log2(cast(10e8 as double))", "DOUBLE",
+ isWithin(29.897352853986263, 0.000001));
+ f.checkScalarApprox("log2(cast(10e8 as float))", "DOUBLE",
+ isWithin(29.897352853986263, 0.000001));
+ f.checkScalarApprox("log2(1e+52)", "DOUBLE",
+ isWithin(172.74026093414284, 0.000001));
+ f.checkNull("log2(0)");
+ f.checkNull("log2(-2)");
+ f.checkNull("log2(+0.0)");
+ f.checkNull("log2(-0.0)");
+ f.checkNull("log2(null)");
+ f.checkNull("log2(cast(null as real))");
+ };
+ f0.forEachLibrary(list(SqlLibrary.MYSQL, SqlLibrary.SPARK), consumer);
+ }
+
@Test void testRandFunc() {
final SqlOperatorFixture f = fixture();
f.setFor(SqlStdOperatorTable.RAND, VmName.EXPAND);
