binary done

Signed-off-by: jayzhan211 <[email protected]>

Author: jayzhan211

datafusion-cli/Cargo.lock

@@ -23,8 +23,8 @@ use std::{any::Any, sync::Arc};
 use crate::expressions::datum::{apply, apply_cmp};
 use crate::intervals::cp_solver::{propagate_arithmetic, propagate_comparison};
 use crate::physical_expr::down_cast_any_ref;
-use crate::sort_properties::SortProperties;
 use crate::physical_expr::PhysicalExpr;
+use crate::sort_properties::SortProperties;
 
 use arrow::array::*;
 use arrow::compute::kernels::boolean::{and_kleene, not, or_kleene};

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

@@ -15,9 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use arrow::array::BooleanArray;
 use arrow::array::{ArrayRef, Datum};
 use arrow::error::ArrowError;
-use arrow::array::BooleanArray;
 use datafusion_common::{Result, ScalarValue};
 use datafusion_expr::ColumnarValue;
 use std::sync::Arc;

datafusion/physical-expr-common/src/expressions/datum.rs

@@ -19,4 +19,3 @@
 
 pub mod cp_solver;
 pub mod utils;
-

datafusion/physical-expr-common/src/intervals/mod.rs

@@ -17,8 +17,8 @@
 
 pub mod aggregate;
 pub mod expressions;
-pub mod physical_expr;
 pub mod intervals;
+pub mod physical_expr;
 pub mod sort_expr;
 pub mod sort_properties;
 pub mod tree_node;

datafusion/physical-expr-common/src/lib.rs

@@ -29,8 +29,9 @@ use datafusion_common::{internal_err, not_impl_err, DFSchema, Result};
 use datafusion_expr::execution_props::ExecutionProps;
 use datafusion_expr::expr::Alias;
 use datafusion_expr::interval_arithmetic::Interval;
-use datafusion_expr::{ColumnarValue, Expr};
+use datafusion_expr::{BinaryExpr, ColumnarValue, Expr};
 
+use crate::expressions::binary::binary;
 use crate::expressions::column::Column;
 use crate::expressions::literal::Literal;
 use crate::sort_properties::SortProperties;
@@ -288,7 +289,7 @@ pub fn create_physical_expr(
     input_dfschema: &DFSchema,
     execution_props: &ExecutionProps,
 ) -> Result<Arc<dyn PhysicalExpr>> {
-    let _input_schema: &Schema = &input_dfschema.into();
+    let input_schema: &Schema = &input_dfschema.into();
 
     match e {
         Expr::Alias(Alias { expr, .. }) => {
@@ -366,19 +367,19 @@ pub fn create_physical_expr(
         //     );
         //     create_physical_expr(&binary_op, input_dfschema, execution_props)
         // }
-        // Expr::BinaryExpr(BinaryExpr { left, op, right }) => {
-        //     // Create physical expressions for left and right operands
-        //     let lhs = create_physical_expr(left, input_dfschema, execution_props)?;
-        //     let rhs = create_physical_expr(right, input_dfschema, execution_props)?;
-        //     // Note that the logical planner is responsible
-        //     // for type coercion on the arguments (e.g. if one
-        //     // argument was originally Int32 and one was
-        //     // Int64 they will both be coerced to Int64).
-        //     //
-        //     // There should be no coercion during physical
-        //     // planning.
-        //     binary(lhs, *op, rhs, input_schema)
-        // }
+        Expr::BinaryExpr(BinaryExpr { left, op, right }) => {
+            // Create physical expressions for left and right operands
+            let lhs = create_physical_expr(left, input_dfschema, execution_props)?;
+            let rhs = create_physical_expr(right, input_dfschema, execution_props)?;
+            // Note that the logical planner is responsible
+            // for type coercion on the arguments (e.g. if one
+            // argument was originally Int32 and one was
+            // Int64 they will both be coerced to Int64).
+            //
+            // There should be no coercion during physical
+            // planning.
+            binary(lhs, *op, rhs, input_schema)
+        }
         // Expr::Like(Like {
         //     negated,
         //     expr,

datafusion/physical-expr-common/src/physical_expr.rs

@@ -20,11 +20,11 @@ use std::{any::Any, sync::Arc};
 
 use crate::{physical_expr::down_cast_any_ref, PhysicalExpr};
 
-use datafusion_physical_expr_common::expressions::datum::apply_cmp;
 use arrow::record_batch::RecordBatch;
 use arrow_schema::{DataType, Schema};
 use datafusion_common::{internal_err, Result};
 use datafusion_expr::ColumnarValue;
+use datafusion_physical_expr_common::expressions::datum::apply_cmp;
 
 // Like expression
 #[derive(Debug, Hash)]

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

@@ -74,21 +74,21 @@ pub use datafusion_functions_aggregate::first_last::{
     FirstValuePhysicalExpr as FirstValue, LastValuePhysicalExpr as LastValue,
 };
 
-pub use datafusion_physical_expr_common::expressions::binary::{binary, BinaryExpr};
 pub use case::{case, CaseExpr};
 pub use cast::{cast, cast_with_options, CastExpr};
 pub use column::UnKnownColumn;
 pub use datafusion_expr::utils::format_state_name;
+pub use datafusion_physical_expr_common::expressions::binary::{binary, BinaryExpr};
 pub use datafusion_physical_expr_common::expressions::column::{col, Column};
 pub use datafusion_physical_expr_common::expressions::literal::{lit, Literal};
+pub use datafusion_physical_expr_common::expressions::try_cast::{try_cast, TryCastExpr};
 pub use in_list::{in_list, InListExpr};
 pub use is_not_null::{is_not_null, IsNotNullExpr};
 pub use is_null::{is_null, IsNullExpr};
 pub use like::{like, LikeExpr};
 pub use negative::{negative, NegativeExpr};
 pub use no_op::NoOp;
 pub use not::{not, NotExpr};
-pub use datafusion_physical_expr_common::expressions::try_cast::{try_cast, TryCastExpr};
 
 #[cfg(test)]
 pub(crate) mod tests {

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

@@ -106,6 +106,14 @@ pub fn create_physical_expr(
     input_dfschema: &DFSchema,
     execution_props: &ExecutionProps,
 ) -> Result<Arc<dyn PhysicalExpr>> {
+    use datafusion_physical_expr_common::physical_expr::create_physical_expr as create_physical_expr_common;
+
+    // Temporary solution, after all the logic is moved to common, we can remove this function
+    let res = create_physical_expr_common(e, input_dfschema, execution_props);
+    if res.is_ok() {
+        return res;
+    }
+
     let input_schema: &Schema = &input_dfschema.into();
 
     match e {