[CALCITE-7187] Java UDF byte arrays cannot be mapped to VARBINARY

core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java

@@ -17,6 +17,7 @@
 package org.apache.calcite.adapter.enumerable;
 
 import org.apache.calcite.adapter.java.JavaTypeFactory;
+import org.apache.calcite.avatica.util.ByteString;
 import org.apache.calcite.avatica.util.DateTimeUtils;
 import org.apache.calcite.linq4j.AbstractEnumerable;
 import org.apache.calcite.linq4j.Enumerable;
@@ -306,6 +307,8 @@ private static Expression toInternal(Expression operand,
       } else if (targetType == Long.class) {
         return Expressions.call(BuiltInMethod.TIMESTAMP_TO_LONG_OPTIONAL.method, operand);
       }
+    } else if (fromType == byte[].class && targetType == ByteString.class) {
+      return Expressions.call(BuiltInMethod.BYTE_ARRAY_TO_BYTE_STRING.method, operand);
     }
     return operand;
   }
@@ -346,6 +349,8 @@ private static Expression fromInternal(Expression operand,
       if (isA(fromType, Primitive.LONG)) {
         return Expressions.call(BuiltInMethod.INTERNAL_TO_TIMESTAMP.method, operand);
       }
+    } else if (targetType == byte[].class && fromType == ByteString.class) {
+      return Expressions.call(BuiltInMethod.BYTE_STRING_TO_BYTE_ARRAY.method, operand);
     }
     if (Primitive.is(operand.type)
         && Primitive.isBox(targetType)) {
@@ -437,6 +442,13 @@ public static Expression convert(Expression operand, Type fromType,
       return operand;
     }
 
+    if (fromType == byte[].class && toType == ByteString.class) {
+      return Expressions.call(BuiltInMethod.BYTE_ARRAY_TO_BYTE_STRING.method, operand);
+    }
+    if (fromType == ByteString.class && toType == byte[].class) {
+      return Expressions.call(BuiltInMethod.BYTE_STRING_TO_BYTE_ARRAY.method, operand);
+    }
+
     // TODO use Expressions#convertChecked to throw exception in case of overflow (CALCITE-6366)
 
     // E.g. from "Short" to "int".

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

@@ -6010,6 +6010,22 @@ public static int time(long timestampMillis, String timeZone) {
     }
   }
 
+  public static @PolyNull ByteString byteArrayToByteString(byte @PolyNull [] bytes) {
+    if (bytes == null) {
+      return null;
+    } else {
+      return new ByteString(bytes);
+    }
+  }
+
+  public static byte @PolyNull [] byteStringToByteArray(@PolyNull ByteString s) {
+    if (s == null) {
+      return null;
+    } else {
+      return s.getBytes();
+    }
+  }
+
   /** Helper for CAST(... AS VARBINARY(maxLength)). */
   public static @PolyNull ByteString truncate(@PolyNull ByteString s, int maxLength) {
     if (s == null) {

core/src/main/java/org/apache/calcite/util/BuiltInMethod.java

@@ -720,6 +720,8 @@ public enum BuiltInMethod {
   STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE(SqlFunctions.class, "toTimestampWithLocalTimeZone",
       String.class),
   STRING_TO_BINARY(SqlFunctions.class, "stringToBinary", String.class, Charset.class),
+  BYTE_ARRAY_TO_BYTE_STRING(SqlFunctions.class, "byteArrayToByteString", byte[].class),
+  BYTE_STRING_TO_BYTE_ARRAY(SqlFunctions.class, "byteStringToByteArray", ByteString.class),
   TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE(SqlFunctions.class,
       "toTimestampWithLocalTimeZone", String.class, TimeZone.class),
   TIME_WITH_LOCAL_TIME_ZONE_TO_TIME(SqlFunctions.class, "timeWithLocalTimeZoneToTime",

core/src/test/java/org/apache/calcite/test/UdfTest.java

@@ -190,6 +190,18 @@ private CalciteAssert.AssertThat withUdf() {
         + "'\n"
         + "         },\n"
         + "         {\n"
+        + "           name: 'BYTEARRAY',\n"
+        + "           className: '"
+        + Smalls.ByteArrayFunction.class.getName()
+        + "'\n"
+        + "         },\n"
+        + "         {\n"
+        + "           name: 'BYTEARRAY_LENGTH',\n"
+        + "           className: '"
+        + Smalls.ByteArrayLengthFunction.class.getName()
+        + "'\n"
+        + "         },\n"
+        + "         {\n"
         + "           name: 'CHARACTERARRAY',\n"
         + "           className: '"
         + Smalls.CharacterArrayFunction.class.getName()
@@ -1107,6 +1119,29 @@ private static CalciteAssert.AssertThat withBadUdf(Class<?> clazz) {
     withUdf().query(sql2).returns("C=true\n");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-7187">[CALCITE-7187]
+   * Java UDF byte arrays cannot be mapped to VARBINARY</a>. */
+  @Test void testByteArrayDirectComparison() {
+    final String testString = "test";
+    final String testHex = "74657374";
+
+    final String sql = "values \"adhoc\".bytearray('" + testString + "')";
+    withUdf().query(sql).typeIs("[EXPR$0 VARBINARY]");
+
+    final String sql2 = "select \"adhoc\".bytearray(cast('" + testString
+        + "' as varchar)) = x'" + testHex + "' as C\n";
+    withUdf().query(sql2).returns("C=true\n");
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-7187">[CALCITE-7187]
+   * Java UDF byte arrays cannot be mapped to VARBINARY</a>. */
+  @Test void testByteArrayParameter() {
+    withUdf().query("values \"adhoc\".bytearray_length(x'74657374')")
+        .returns("EXPR$0=4\n");
+  }
+
   /**
    * Test for <a href="https://issues.apache.org/jira/browse/CALCITE-7186">[CALCITE-7186]</a>
    * Add mapping from Character[] to VARCHAR in Java UDF.

site/_docs/reference.md

@@ -3426,6 +3426,10 @@ can specify the name and optionality of each parameter using the
 [Parameter]({{ site.apiRoot }}/org/apache/calcite/linq4j/function/Parameter.html)
 annotation.
 
+For Java UDFs, `byte[]` and `ByteString` are supported Java representations of
+SQL `VARBINARY` values for parameters and return types. Boxed byte arrays
+(`Byte[]`) are not supported.
+
 ### Calling functions with named and optional parameters
 
 Usually when you call a function, you need to specify all of its parameters,

testkit/src/main/java/org/apache/calcite/util/Smalls.java

@@ -69,6 +69,7 @@
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.math.BigDecimal;
+import java.nio.charset.StandardCharsets;
 import java.sql.Date;
 import java.sql.Time;
 import java.sql.Timestamp;
@@ -1493,6 +1494,23 @@ public static ByteString eval(String s) {
     }
   }
 
+  /** User-defined function with return type byte[]. */
+  public static class ByteArrayFunction {
+    public static byte[] eval(String s) {
+      if (s == null) {
+        return null;
+      }
+      return s.getBytes(StandardCharsets.UTF_8);
+    }
+  }
+
+  /** User-defined function with parameter type byte[]. */
+  public static class ByteArrayLengthFunction {
+    public static int eval(byte[] bytes) {
+      return bytes.length;
+    }
+  }
+
   /** User-defined function with return type Character[]. */
   public static class CharacterArrayFunction {
     public static Character[] eval(String s) {