slt for new operators

Signed-off-by: Ruihang Xia <waynestxia@gmail.com>

Author: waynexia

datafusion/expr-common/src/type_coercion/binary.rs

@@ -30,8 +30,8 @@ use arrow::datatypes::{
 };
 use datafusion_common::types::NativeType;
 use datafusion_common::{
-    exec_err, internal_err, plan_datafusion_err, plan_err, Diagnostic, Result, Span,
-    Spans,
+    exec_err, internal_err, not_impl_err, plan_datafusion_err, plan_err, Diagnostic,
+    Result, Span, Spans,
 };
 use itertools::Itertools;
 
@@ -181,13 +181,20 @@ impl<'a> BinaryTypeCoercer<'a> {
                 )
             })
         }
-        AtArrow | ArrowAt | Arrow | LongArrow | HashArrow | HashLongArrow | AtAt | HashMinus |
-        AtQuestion | Question | QuestionAnd | QuestionPipe |IntegerDivide=> {
-            // These operators check for whether one array is contained in another or other JSON operations.
-            // The result type is boolean. Signature::comparison defines this signature.
-            array_coercion(self.lhs, self.rhs).map(Signature::comparison).ok_or_else(|| {
+        AtArrow | ArrowAt => {
+            // Array contains or search (similar to LIKE) operation
+            array_coercion(self.lhs, self.rhs)
+                .or_else(|| like_coercion(self.lhs, self.rhs)).map(Signature::comparison).ok_or_else(|| {
+                    plan_datafusion_err!(
+                        "Cannot infer common argument type for operation {} {} {}", self.lhs, self.op, self.rhs
+                    )
+                })
+        }
+        AtAt => {
+            // text search has similar signature to LIKE
+            like_coercion(self.lhs, self.rhs).map(Signature::comparison).ok_or_else(|| {
                 plan_datafusion_err!(
-                    "Cannot infer common array type for operation {} {} {}", self.lhs, self.op, self.rhs
+                    "Cannot infer common argument type for AtAt operation {} {} {}", self.lhs, self.op, self.rhs
                 )
             })
         }
@@ -248,6 +255,10 @@ impl<'a> BinaryTypeCoercer<'a> {
                     "Cannot coerce arithmetic expression {} {} {} to valid types", self.lhs, self.op, self.rhs
                 )
             }
+        },
+        IntegerDivide | Arrow | LongArrow | HashArrow | HashLongArrow
+        | HashMinus | AtQuestion | Question | QuestionAnd | QuestionPipe => {
+            not_impl_err!("Operator {} is not yet supported", self.op)
         }
     };
         result.map_err(|err| {

datafusion/physical-expr/src/expressions/binary.rs

@@ -33,7 +33,7 @@ use arrow::compute::{cast, ilike, like, nilike, nlike};
 use arrow::datatypes::*;
 use arrow::error::ArrowError;
 use datafusion_common::cast::as_boolean_array;
-use datafusion_common::{internal_err, Result, ScalarValue};
+use datafusion_common::{internal_err, not_impl_err, Result, ScalarValue};
 use datafusion_expr::binary::BinaryTypeCoercer;
 use datafusion_expr::interval_arithmetic::{apply_operator, Interval};
 use datafusion_expr::sort_properties::ExprProperties;
@@ -796,7 +796,10 @@ impl BinaryExpr {
             AtArrow | ArrowAt | Arrow | LongArrow | HashArrow | HashLongArrow | AtAt
             | HashMinus | AtQuestion | Question | QuestionAnd | QuestionPipe
             | IntegerDivide => {
-                unreachable!("These operators should be rewritten to functions")
+                not_impl_err!(
+                    "Binary operator '{:?}' is not supported in the physical expr",
+                    self.op
+                )
             }
         }
     }

datafusion/sqllogictest/test_files/expr.slt

@@ -1648,6 +1648,56 @@ true
 true
 true
 
+#### Other binary operators
+
+# ArrowAt for strings
+query error
+select 'foo' <@ 'bar'
+
+# AtArrow for strings
+query error
+select 'foo' @> 'bar'
+
+# AtAt for strings
+query error
+select 'foo' @@ 'bar'
+
+# Arrow for arrays
+query error
+select make_array(1,2,3) -> 2
+
+# LongArrow for arrays
+query error
+select make_array(1,2,3) ->> 2
+
+# HashArrow for structs
+query error
+select struct(1,2,3) #> 0
+
+# HashLongArrow for structs
+query error
+select struct(1,2,3) #>> 0
+
+# HashMinus for structs
+query error
+select struct(1,2,3) #- 0
+
+# AtQuestion for JSON/structs
+query error
+select struct(1,2,3) @? 'a.b.c'
+
+# Question for JSON/structs
+query error
+select struct(1,2,3) ? 'a.b.c'
+
+# QuestionPipe for JSON/structs
+query error
+select struct(1,2,3) ?| array['a','b','c']
+
+# QuestionAnd for JSON/structs
+query error
+select struct(1,2,3) ?& array['a','b','c']
+
 #### binary_mathematical_operator_with_null_lt
 
 # 1. Integer and NULL