ARROW-9988: [Rust] [DataFusion] Added +-/* as operators to logical expressions.

rust/datafusion/src/dataframe.rs

@@ -71,7 +71,7 @@ pub trait DataFrame {
     /// # fn main() -> Result<()> {
     /// let mut ctx = ExecutionContext::new();
     /// let df = ctx.read_csv("tests/example.csv", CsvReadOptions::new())?;
-    /// let df = df.select(vec![col("a").multiply(col("b")), col("c")])?;
+    /// let df = df.select(vec![col("a") * col("b"), col("c")])?;
     /// # Ok(())
     /// # }
     /// ```

rust/datafusion/src/logical_plan/mod.rs

@@ -40,66 +40,8 @@ use crate::{
 use arrow::record_batch::RecordBatch;
 use functions::{ReturnTypeFunction, ScalarFunctionImplementation, Signature};
 
-/// Operators applied to expressions
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum Operator {
-    /// Expressions are equal
-    Eq,
-    /// Expressions are not equal
-    NotEq,
-    /// Left side is smaller than right side
-    Lt,
-    /// Left side is smaller or equal to right side
-    LtEq,
-    /// Left side is greater than right side
-    Gt,
-    /// Left side is greater or equal to right side
-    GtEq,
-    /// Addition
-    Plus,
-    /// Subtraction
-    Minus,
-    /// Multiplication operator, like `*`
-    Multiply,
-    /// Division operator, like `/`
-    Divide,
-    /// Remainder operator, like `%`
-    Modulus,
-    /// Logical AND, like `&&`
-    And,
-    /// Logical OR, like `||`
-    Or,
-    /// Logical NOT, like `!`
-    Not,
-    /// Matches a wildcard pattern
-    Like,
-    /// Does not match a wildcard pattern
-    NotLike,
-}
-
-impl fmt::Display for Operator {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let display = match &self {
-            Operator::Eq => "=",
-            Operator::NotEq => "!=",
-            Operator::Lt => "<",
-            Operator::LtEq => "<=",
-            Operator::Gt => ">",
-            Operator::GtEq => ">=",
-            Operator::Plus => "+",
-            Operator::Minus => "-",
-            Operator::Multiply => "*",
-            Operator::Divide => "/",
-            Operator::Modulus => "%",
-            Operator::And => "AND",
-            Operator::Or => "OR",
-            Operator::Not => "NOT",
-            Operator::Like => "LIKE",
-            Operator::NotLike => "NOT LIKE",
-        };
-        write!(f, "{}", display)
-    }
-}
+mod operators;
+pub use operators::Operator;
 
 /// ScalarValue enumeration
 #[derive(Debug, Clone, PartialEq)]
@@ -459,26 +401,6 @@ impl Expr {
         Expr::Not(Box::new(self.clone()))
     }
 
-    /// Add the specified expression
-    pub fn plus(&self, other: Expr) -> Expr {
-        binary_expr(self.clone(), Operator::Plus, other.clone())
-    }
-
-    /// Subtract the specified expression
-    pub fn minus(&self, other: Expr) -> Expr {
-        binary_expr(self.clone(), Operator::Minus, other.clone())
-    }
-
-    /// Multiply by the specified expression
-    pub fn multiply(&self, other: Expr) -> Expr {
-        binary_expr(self.clone(), Operator::Multiply, other.clone())
-    }
-
-    /// Divide by the specified expression
-    pub fn divide(&self, other: Expr) -> Expr {
-        binary_expr(self.clone(), Operator::Divide, other.clone())
-    }
-
     /// Calculate the modulus of two expressions
     pub fn modulus(&self, other: Expr) -> Expr {
         binary_expr(self.clone(), Operator::Modulus, other.clone())

rust/datafusion/src/logical_plan/operators.rs

@@ -0,0 +1,141 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+use std::{fmt, ops};
+
+use super::{binary_expr, Expr};
+
+/// Operators applied to expressions
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Operator {
+    /// Expressions are equal
+    Eq,
+    /// Expressions are not equal
+    NotEq,
+    /// Left side is smaller than right side
+    Lt,
+    /// Left side is smaller or equal to right side
+    LtEq,
+    /// Left side is greater than right side
+    Gt,
+    /// Left side is greater or equal to right side
+    GtEq,
+    /// Addition
+    Plus,
+    /// Subtraction
+    Minus,
+    /// Multiplication operator, like `*`
+    Multiply,
+    /// Division operator, like `/`
+    Divide,
+    /// Remainder operator, like `%`
+    Modulus,
+    /// Logical AND, like `&&`
+    And,
+    /// Logical OR, like `||`
+    Or,
+    /// Logical NOT, like `!`
+    Not,
+    /// Matches a wildcard pattern
+    Like,
+    /// Does not match a wildcard pattern
+    NotLike,
+}
+
+impl fmt::Display for Operator {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let display = match &self {
+            Operator::Eq => "=",
+            Operator::NotEq => "!=",
+            Operator::Lt => "<",
+            Operator::LtEq => "<=",
+            Operator::Gt => ">",
+            Operator::GtEq => ">=",
+            Operator::Plus => "+",
+            Operator::Minus => "-",
+            Operator::Multiply => "*",
+            Operator::Divide => "/",
+            Operator::Modulus => "%",
+            Operator::And => "AND",
+            Operator::Or => "OR",
+            Operator::Not => "NOT",
+            Operator::Like => "LIKE",
+            Operator::NotLike => "NOT LIKE",
+        };
+        write!(f, "{}", display)
+    }
+}
+
+impl ops::Add for Expr {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self {
+        binary_expr(self.clone(), Operator::Plus, rhs.clone())
+    }
+}
+
+impl ops::Sub for Expr {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self {
+        binary_expr(self.clone(), Operator::Minus, rhs.clone())
+    }
+}
+
+impl ops::Mul for Expr {
+    type Output = Self;
+
+    fn mul(self, rhs: Self) -> Self {
+        binary_expr(self.clone(), Operator::Multiply, rhs.clone())
+    }
+}
+
+impl ops::Div for Expr {
+    type Output = Self;
+
+    fn div(self, rhs: Self) -> Self {
+        binary_expr(self.clone(), Operator::Divide, rhs.clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::error::Result;
+    use crate::prelude::lit;
+
+    #[test]
+    fn test_operators() -> Result<()> {
+        assert_eq!(
+            format!("{:?}", lit(1u32) + lit(2u32)),
+            "UInt32(1) Plus UInt32(2)"
+        );
+        assert_eq!(
+            format!("{:?}", lit(1u32) - lit(2u32)),
+            "UInt32(1) Minus UInt32(2)"
+        );
+        assert_eq!(
+            format!("{:?}", lit(1u32) * lit(2u32)),
+            "UInt32(1) Multiply UInt32(2)"
+        );
+        assert_eq!(
+            format!("{:?}", lit(1u32) / lit(2u32)),
+            "UInt32(1) Divide UInt32(2)"
+        );
+
+        Ok(())
+    }
+}