Make varchar and varbinary compatible

velox/connectors/hive/HiveConnector.cpp

@@ -309,7 +309,8 @@ bool testFilters(
 template <TypeKind ToKind>
 velox::variant convertFromString(const std::optional<std::string>& value) {
   if (value.has_value()) {
-    if constexpr (ToKind == TypeKind::VARCHAR) {
+    // No need for casting if ToKind is VARCHAR or VARBINARY.
+    if constexpr (ToKind == TypeKind::VARCHAR || ToKind == TypeKind::VARBINARY) {
       return velox::variant(value.value());
     }
     bool nullOutput = false;

velox/substrait/SubstraitToVeloxExpr.cpp

@@ -456,18 +456,6 @@ SubstraitVeloxExprConverter::toVeloxExpr(
 
   std::vector<core::TypedExprPtr> inputs{
       toVeloxExpr(castExpr.input(), inputType)};
-
-  // TODO: refactor this part for input type validation.
-  for (const auto& input : inputs) {
-    switch (input->type()->kind()) {
-      case TypeKind::ARRAY: {
-        // Cast from array type is not supported. See CastExpr::applyCast.
-        VELOX_UNSUPPORTED("Invalid from type in casting: {}", input->type());
-      }
-      default: {
-      }
-    }
-  }
   return std::make_shared<core::CastTypedExpr>(type, inputs, nullOnFailure);
 }
 

velox/substrait/SubstraitToVeloxPlanValidator.cpp

@@ -94,6 +94,28 @@ bool SubstraitToVeloxPlanValidator::validateLiteral(
   return true;
 }
 
+bool SubstraitToVeloxPlanValidator::validateCast(
+    const ::substrait::Expression::Cast& castExpr,
+    const RowTypePtr& inputType) {
+  std::vector<core::TypedExprPtr> inputs{
+      exprConverter_->toVeloxExpr(castExpr.input(), inputType)};
+
+  // Casting from some types is not supported. See CastExpr::applyCast.
+  for (const auto& input : inputs) {
+    switch (input->type()->kind()) {
+      case TypeKind::ARRAY:
+      case TypeKind::MAP:
+      case TypeKind::ROW:
+      case TypeKind::VARBINARY:
+        VLOG(1) << "Invalid input type in casting: " << input->type() << ".";
+        return false;
+      default: {
+      }
+    }
+  }
+  return true;
+}
+
 bool SubstraitToVeloxPlanValidator::validateExpression(
     const ::substrait::Expression& expression,
     const RowTypePtr& inputType) {
@@ -104,6 +126,8 @@ bool SubstraitToVeloxPlanValidator::validateExpression(
       return validateScalarFunction(expression.scalar_function(), inputType);
     case ::substrait::Expression::RexTypeCase::kLiteral:
       return validateLiteral(expression.literal(), inputType);
+    case ::substrait::Expression::RexTypeCase::kCast:
+      return validateCast(expression.cast(), inputType);
     default:
       return true;
   }

velox/substrait/SubstraitToVeloxPlanValidator.h

@@ -101,6 +101,11 @@ class SubstraitToVeloxPlanValidator {
       const ::substrait::Expression::ScalarFunction& scalarFunction,
       const RowTypePtr& inputType);
 
+  /// Validate Substrait Cast expression.
+  bool validateCast(
+    const ::substrait::Expression::Cast& castExpr,
+    const RowTypePtr& inputType);  
+
   /// Validate Substrait expression.
   bool validateExpression(
       const ::substrait::Expression& expression,

velox/vector/BaseVector.h

@@ -669,7 +669,10 @@ class BaseVector {
   // two unknowns but values cannot be assigned into an unknown 'left'
   // from a not-unknown 'right'.
   static bool compatibleKind(TypeKind left, TypeKind right) {
-    return left == right || right == TypeKind::UNKNOWN;
+    // Vectors of VARCHAR and VARBINARY are compatible with each other.
+    bool varcharAndBinary = (left == TypeKind::VARCHAR && right == TypeKind::VARBINARY) ||
+        (left == TypeKind::VARBINARY && right == TypeKind::VARCHAR);
+    return left == right || right == TypeKind::UNKNOWN || varcharAndBinary;
   }
 
   /// Returns a brief summary of the vector. If 'recursive' is true, includes a