Restore legacy SQL hash function names as aliases

Critical fix:
- HashFunctions.java: when this branch added @ScalarFunction(names =
  {"murmur2", ...}) on existing public byte[]-overload hash functions
  (murmurHash2, fnv1Hash32, fnv1aHash32, fnv1Hash64, fnv1aHash64), the
  explicit names array overrode the auto-derived canonical name —
  silently breaking existing user SQL queries / ingestion transforms /
  views that called these functions on byte[] inputs by their original
  names. Add the legacy camelCase names alongside the new short aliases
  so both resolve to the same method:
    @ScalarFunction(names = {"murmur2",  "murmurHash2"})
    @ScalarFunction(names = {"fnv1_32",  "fnv1Hash32"})
    @ScalarFunction(names = {"fnv1a_32", "fnv1aHash32"})
    @ScalarFunction(names = {"fnv1_64",  "fnv1Hash64"})
    @ScalarFunction(names = {"fnv1a_64", "fnv1aHash64"})
  (murmur3Bit32Default is a new 1-arg method introduced by this branch
  with no upstream auto-derived name to preserve, so its single
  "murmur3_32" alias is fine.)

- HashFunctionsTest: add testLegacyAndNewHashFunctionAliasesBothResolve
  asserting both the legacy and new alias resolve via FunctionRegistry
  to the same method, locking the contract so a future name reshuffle
  cannot silently regress backward compatibility.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: xiangfu0

pinot-common/src/main/java/org/apache/pinot/common/function/scalar/HashFunctions.java

@@ -122,7 +122,9 @@ public static byte[] md5Raw(byte[] input) {
    * @param input the byte array to hash
    * @return 32-bit hash
    */
-  @ScalarFunction(names = {"murmur2"})
+  // "murmurHash2" preserves the canonical name auto-derived on master before this PR introduced the "murmur2" alias.
+  // Existing user SQL queries / ingestion transforms calling murmurHash2(byte_col) must continue to resolve.
+  @ScalarFunction(names = {"murmur2", "murmurHash2"})
   public static int murmurHash2(byte[] input) {
     return MurmurHashFunctions.murmurHash2(input);
   }
@@ -240,7 +242,8 @@ public static byte[] murmurHash3X64Bit128(byte[] input, int seed) {
    * @param input the byte array to hash
    * @return 32-bit hash
    */
-  @ScalarFunction(names = {"fnv1_32"})
+  // "fnv1Hash32" preserves the canonical name auto-derived on master before this PR introduced the "fnv1_32" alias.
+  @ScalarFunction(names = {"fnv1_32", "fnv1Hash32"})
   public static int fnv1Hash32(byte[] input) {
     return FnvHashFunctions.fnv1Hash32(input);
   }
@@ -262,7 +265,8 @@ public static int fnv1Hash32UTF8(String input) {
    * @param input the byte array to hash
    * @return 32-bit hash
    */
-  @ScalarFunction(names = {"fnv1a_32"})
+  // "fnv1aHash32" preserves the canonical name auto-derived on master before this PR introduced the "fnv1a_32" alias.
+  @ScalarFunction(names = {"fnv1a_32", "fnv1aHash32"})
   public static int fnv1aHash32(byte[] input) {
     return FnvHashFunctions.fnv1aHash32(input);
   }
@@ -284,7 +288,8 @@ public static int fnv1aHash32UTF8(String input) {
    * @param input the byte array to hash
    * @return 64-bit hash
    */
-  @ScalarFunction(names = {"fnv1_64"})
+  // "fnv1Hash64" preserves the canonical name auto-derived on master before this PR introduced the "fnv1_64" alias.
+  @ScalarFunction(names = {"fnv1_64", "fnv1Hash64"})
   public static long fnv1Hash64(byte[] input) {
     return FnvHashFunctions.fnv1Hash64(input);
   }
@@ -306,7 +311,8 @@ public static long fnv1Hash64UTF8(String input) {
    * @param input the byte array to hash
    * @return 64-bit hash
    */
-  @ScalarFunction(names = {"fnv1a_64"})
+  // "fnv1aHash64" preserves the canonical name auto-derived on master before this PR introduced the "fnv1a_64" alias.
+  @ScalarFunction(names = {"fnv1a_64", "fnv1aHash64"})
   public static long fnv1aHash64(byte[] input) {
     return FnvHashFunctions.fnv1aHash64(input);
   }

pinot-common/src/test/java/org/apache/pinot/common/function/scalar/HashFunctionsTest.java

@@ -19,10 +19,13 @@
 package org.apache.pinot.common.function.scalar;
 
 import java.nio.charset.StandardCharsets;
+import org.apache.pinot.common.function.FunctionInfo;
+import org.apache.pinot.common.function.FunctionRegistry;
 import org.apache.pinot.spi.utils.hash.FnvHashFunctions;
 import org.testng.annotations.Test;
 
 import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertNotNull;
 
 
 public class HashFunctionsTest {
@@ -225,4 +228,34 @@ public void testCityHash128() {
     assertEquals(HashFunctions.cityHash128(INPUT_LEN_156.getBytes()),
             new byte[] {114, 8, 23, 53, -124, 83, -28, 35, 27, -117, -59, 121, -108, -20, 59, 115});
   }
+
+  /**
+   * Backward-compat regression: this branch added explicit {@code @ScalarFunction(names = {"murmur2", ...})}
+   * aliases to byte[]-overload hash functions. The {@code names} array overrides the auto-derived canonical name
+   * from the method, so without explicitly listing the original (camelCase) name, existing user SQL queries calling
+   * {@code murmurHash2}/{@code fnv1Hash32}/{@code fnv1aHash32}/{@code fnv1Hash64}/{@code fnv1aHash64} on a byte[]
+   * argument would silently stop resolving the byte[] overload after upgrade. This test locks both the new short
+   * alias and the legacy auto-derived name so future name reshuffles cannot regress backward compatibility.
+   */
+  @Test
+  public void testLegacyAndNewHashFunctionAliasesBothResolve() {
+    // Note: lookupFunctionInfo expects canonicalized names (lowercased, underscores stripped). Both the legacy
+    // camelCase name and the new alias should canonicalize to a registered key.
+    String[][] aliasPairs = new String[][] {
+        // {legacy auto-derived name, new alias}
+        {"murmurHash2", "murmur2"},
+        {"fnv1Hash32", "fnv1_32"},
+        {"fnv1aHash32", "fnv1a_32"},
+        {"fnv1Hash64", "fnv1_64"},
+        {"fnv1aHash64", "fnv1a_64"},
+    };
+    for (String[] pair : aliasPairs) {
+      FunctionInfo legacy = FunctionRegistry.lookupFunctionInfo(FunctionRegistry.canonicalize(pair[0]), 1);
+      FunctionInfo alias = FunctionRegistry.lookupFunctionInfo(FunctionRegistry.canonicalize(pair[1]), 1);
+      assertNotNull(legacy, "Legacy alias must still resolve: " + pair[0]);
+      assertNotNull(alias, "New alias must resolve: " + pair[1]);
+      assertEquals(legacy.getMethod(), alias.getMethod(),
+          "Legacy and new aliases must resolve to the same method: " + pair[0] + " vs " + pair[1]);
+    }
+  }
 }