You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by ag...@apache.org on 2020/09/15 23:59:32 UTC
[arrow] branch master updated: ARROW-9988: [Rust] [DataFusion]
Added +-/* as operators to logical expressions.
This is an automated email from the ASF dual-hosted git repository.
agrove pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow.git
The following commit(s) were added to refs/heads/master by this push:
new b3a6da1 ARROW-9988: [Rust] [DataFusion] Added +-/* as operators to logical expressions.
b3a6da1 is described below
commit b3a6da16cf51069cc3a6a45e5d4a3bc96c3d1613
Author: Jorge C. Leitao <jo...@gmail.com>
AuthorDate: Tue Sep 15 17:58:39 2020 -0600
ARROW-9988: [Rust] [DataFusion] Added +-/* as operators to logical expressions.
Also moved operators to their own module.
Closes #8182 from jorgecarleitao/ops
Authored-by: Jorge C. Leitao <jo...@gmail.com>
Signed-off-by: Andy Grove <an...@nvidia.com>
---
rust/datafusion/src/dataframe.rs | 2 +-
rust/datafusion/src/logical_plan/mod.rs | 82 +--------------
rust/datafusion/src/logical_plan/operators.rs | 141 ++++++++++++++++++++++++++
3 files changed, 144 insertions(+), 81 deletions(-)
diff --git a/rust/datafusion/src/dataframe.rs b/rust/datafusion/src/dataframe.rs
index b839c48..ae3bf3a 100644
--- a/rust/datafusion/src/dataframe.rs
+++ b/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(())
/// # }
/// ```
diff --git a/rust/datafusion/src/logical_plan/mod.rs b/rust/datafusion/src/logical_plan/mod.rs
index 60dbcc3..9c11d23 100644
--- a/rust/datafusion/src/logical_plan/mod.rs
+++ b/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())
diff --git a/rust/datafusion/src/logical_plan/operators.rs b/rust/datafusion/src/logical_plan/operators.rs
new file mode 100644
index 0000000..e17c7cc
--- /dev/null
+++ b/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(())
+ }
+}