Method evaluate

datafusion/physical-expr/src/expressions/binary.rs:273–392

(&self, batch: &RecordBatch)

    }

    fn evaluate(&self, batch: &RecordBatch) -> Result<ColumnarValue> {
        use arrow::compute::kernels::numeric::*;

        // Evaluate left-hand side expression.
        let lhs = self.left.evaluate(batch)?;

        // Check if we can apply short-circuit evaluation.
        match check_short_circuit(&lhs, &self.op) {
            ShortCircuitStrategy::None => {}
            ShortCircuitStrategy::ReturnLeft => return Ok(lhs),
            ShortCircuitStrategy::ReturnRight => {
                let rhs = self.right.evaluate(batch)?;
                return Ok(rhs);
            }
            ShortCircuitStrategy::PreSelection(selection) => {
                // The function `evaluate_selection` was not called for filtering and calculation,
                // as it takes into account cases where the selection contains null values.
                let batch = filter_record_batch(batch, selection)?;
                let right_ret = self.right.evaluate(&batch)?;

                match &right_ret {
                    ColumnarValue::Array(array) => {
                        // When the array on the right is all true or all false, skip the scatter process
                        let boolean_array = array.as_boolean();
                        if boolean_array.null_count() == 0 && !boolean_array.has_false() {
                            return Ok(lhs);
                        } else if boolean_array.null_count() == 0
                            && !boolean_array.has_true()
                        {
                            // If the right-hand array is returned at this point,the lengths will be inconsistent;
                            // returning a scalar can avoid this issue
                            return Ok(ColumnarValue::Scalar(ScalarValue::Boolean(
                                Some(false),
                            )));
                        }

                        return pre_selection_scatter(selection, Some(boolean_array));
                    }
                    ColumnarValue::Scalar(scalar) => {
                        if let ScalarValue::Boolean(v) = scalar {
                            // When the scalar is true or false, skip the scatter process
                            if let Some(v) = v {
                                if *v {
                                    return Ok(lhs);
                                } else {
                                    return Ok(right_ret);
                                }
                            } else {
                                return pre_selection_scatter(selection, None);
                            }
                        } else {
                            return internal_err!(
                                "Expected boolean scalar value, found: {right_ret:?}"
                            );
                        }
                    }
                }
            }