Added coercion rules and placeholder UDF to handle VARBINARY

Signed-off-by: Vinay Krishna Pudyodu <vinkrish.neo@gmail.com>

Author: vinaykpud

core/src/main/java/org/opensearch/sql/calcite/ExtendedRexBuilder.java

@@ -183,6 +183,12 @@ else if ((SqlTypeUtil.isApproximateNumeric(sourceType) || SqlTypeUtil.isDecimal(
       // NUMBER_TO_STRING uses java's built-in method to get the string representation of a number
       return makeCall(type, PPLBuiltinOperators.NUMBER_TO_STRING, List.of(exp));
     }
+    // VARCHAR → VARBINARY for ip/binary fields. Emit BINARY(varchar) as a placeholder
+    // RexCall the analytics backend adapter rewrites into a VARBINARY literal.
+    else if (sqlType == SqlTypeName.VARBINARY
+        && sourceType.getSqlTypeName() == SqlTypeName.VARCHAR) {
+      return makeCall(type, PPLBuiltinOperators.BINARY, List.of(exp));
+    }
     return super.makeCast(pos, type, exp, matchNullability, safe, format);
   }
 }

core/src/main/java/org/opensearch/sql/calcite/utils/OpenSearchTypeFactory.java

@@ -174,6 +174,8 @@ public static RelDataType convertExprTypeToRelDataType(ExprType fieldType, boole
           return TYPE_FACTORY.createUDT(ExprUDT.EXPR_TIME, nullable);
         case TIMESTAMP:
           return TYPE_FACTORY.createUDT(ExprUDT.EXPR_TIMESTAMP, nullable);
+        case BINARY:
+          return TYPE_FACTORY.createSqlType(SqlTypeName.VARBINARY, nullable);
         case ARRAY:
           return TYPE_FACTORY.createArrayType(
               TYPE_FACTORY.createSqlType(SqlTypeName.ANY, nullable), -1);
@@ -225,6 +227,7 @@ public static ExprType convertSqlTypeNameToExprType(SqlTypeName sqlTypeName) {
       case FLOAT, REAL -> FLOAT;
       case DOUBLE, DECIMAL -> DOUBLE; // TODO the decimal is only used for literal
       case CHAR, VARCHAR, MULTISET -> STRING; // call toString() for MULTISET
+      case VARBINARY, BINARY -> BINARY;
       case BOOLEAN -> BOOLEAN;
       case DATE -> DATE;
       case TIME, TIME_TZ, TIME_WITH_LOCAL_TIME_ZONE -> TIME;

core/src/main/java/org/opensearch/sql/expression/function/CoercionUtils.java

@@ -181,7 +181,12 @@ public static boolean hasString(List<RexNode> rexNodeList) {
               (left, right) -> ExprCoreType.TIMESTAMP),
           CoercionRule.of(
               (left, right) -> hasString(left, right) && hasNumber(left, right),
-              (left, right) -> ExprCoreType.DOUBLE));
+              (left, right) -> ExprCoreType.DOUBLE),
+          // (BINARY, STRING) → BINARY: ip/binary columns compared with string literals.
+          // Triggers ExtendedRexBuilder.makeCast which wraps the literal with BINARY.
+          CoercionRule.of(
+              (left, right) -> hasString(left, right) && hasBinary(left, right),
+              (left, right) -> ExprCoreType.BINARY));
 
   private static boolean hasString(ExprType left, ExprType right) {
     return left == ExprCoreType.STRING || right == ExprCoreType.STRING;
@@ -195,6 +200,10 @@ private static boolean hasBoolean(ExprType left, ExprType right) {
     return left == ExprCoreType.BOOLEAN || right == ExprCoreType.BOOLEAN;
   }
 
+  private static boolean hasBinary(ExprType left, ExprType right) {
+    return left == ExprCoreType.BINARY || right == ExprCoreType.BINARY;
+  }
+
   private record CoercionRule(
       BiPredicate<ExprType, ExprType> predicate, BinaryOperator<ExprType> resolver) {
 

core/src/main/java/org/opensearch/sql/expression/function/PPLBuiltinOperators.java

@@ -83,6 +83,7 @@
 import org.opensearch.sql.expression.function.udf.condition.EarliestFunction;
 import org.opensearch.sql.expression.function.udf.condition.EnhancedCoalesceFunction;
 import org.opensearch.sql.expression.function.udf.condition.LatestFunction;
+import org.opensearch.sql.expression.function.udf.conversion.BinaryFunction;
 import org.opensearch.sql.expression.function.udf.datetime.AddSubDateFunction;
 import org.opensearch.sql.expression.function.udf.datetime.CurrentFunction;
 import org.opensearch.sql.expression.function.udf.datetime.DateAddSubFunction;
@@ -179,6 +180,9 @@ public class PPLBuiltinOperators extends ReflectiveSqlOperatorTable {
   public static final SqlOperator EARLIEST = new EarliestFunction().toUDF("EARLIEST");
   public static final SqlOperator LATEST = new LatestFunction().toUDF("LATEST");
 
+  // VARBINARY conversion (placeholder for ip/binary fields rewritten by analytics backend adapter)
+  public static final SqlOperator BINARY = new BinaryFunction().toUDF("BINARY");
+
   // Datetime function
   public static final SqlOperator TIMESTAMP = new TimestampFunction().toUDF("TIMESTAMP");
   public static final SqlOperator DATE =

core/src/main/java/org/opensearch/sql/expression/function/udf/conversion/BinaryFunction.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.expression.function.udf.conversion;
+
+import static org.opensearch.sql.calcite.utils.OpenSearchTypeFactory.TYPE_FACTORY;
+
+import java.util.List;
+import org.apache.calcite.adapter.enumerable.NotNullImplementor;
+import org.apache.calcite.adapter.enumerable.NullPolicy;
+import org.apache.calcite.adapter.enumerable.RexToLixTranslator;
+import org.apache.calcite.linq4j.tree.Expression;
+import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.sql.type.FamilyOperandTypeChecker;
+import org.apache.calcite.sql.type.OperandTypes;
+import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlReturnTypeInference;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.opensearch.sql.expression.function.ImplementorUDF;
+import org.opensearch.sql.expression.function.UDFOperandMetadata;
+
+/**
+ * Placeholder UDF that wraps a VARCHAR literal cast to VARBINARY for ip/binary fields.
+ */
+public class BinaryFunction extends ImplementorUDF {
+
+  private static final SqlReturnTypeInference VARBINARY_FORCE_NULLABLE =
+      ReturnTypes.explicit(
+          TYPE_FACTORY.createTypeWithNullability(
+              TYPE_FACTORY.createSqlType(SqlTypeName.VARBINARY), true));
+
+  public BinaryFunction() {
+    super(new PassThroughImplementor(), NullPolicy.STRICT);
+  }
+
+  @Override
+  public SqlReturnTypeInference getReturnTypeInference() {
+    return VARBINARY_FORCE_NULLABLE;
+  }
+
+  @Override
+  public UDFOperandMetadata getOperandMetadata() {
+    return UDFOperandMetadata.wrap((FamilyOperandTypeChecker) OperandTypes.CHARACTER);
+  }
+
+  public static class PassThroughImplementor implements NotNullImplementor {
+    @Override
+    public Expression implement(
+        RexToLixTranslator translator, RexCall call, List<Expression> translatedOperands) {
+      return translatedOperands.get(0);
+    }
+  }
+}