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-datafusion.git
The following commit(s) were added to refs/heads/master by this push:
new 17d02177b Refactor `Expr::Like`, `Expr::ILike`, `Expr::SimilarTo` to
use a struct (#3836)
17d02177b is described below
commit 17d02177bbf00a05a7f785f960c24d45adbda8b9
Author: baishen <[email protected]>
AuthorDate: Sun Oct 16 04:21:33 2022 +0800
Refactor `Expr::Like`, `Expr::ILike`, `Expr::SimilarTo` to use a struct
(#3836)
* Refactor `Expr::Like`, `Expr::ILike`, `Expr::SimilarTo` to use a struct
* optimize type
* fix clippy
---
datafusion/core/src/physical_plan/planner.rs | 14 ++--
datafusion/expr/src/expr.rs | 98 +++++++++++++---------------
datafusion/expr/src/expr_rewriter.rs | 32 ++++-----
datafusion/expr/src/expr_schema.rs | 8 +--
datafusion/expr/src/expr_visitor.rs | 8 +--
datafusion/expr/src/lib.rs | 2 +-
datafusion/optimizer/src/type_coercion.rs | 46 ++++---------
datafusion/physical-expr/src/planner.rs | 6 +-
datafusion/proto/src/from_proto.rs | 38 +++++------
datafusion/proto/src/lib.rs | 26 ++++----
datafusion/proto/src/to_proto.rs | 23 ++-----
datafusion/row/src/writer.rs | 2 +-
datafusion/sql/src/planner.rs | 27 ++++----
datafusion/sql/src/utils.rs | 44 ++++++-------
14 files changed, 165 insertions(+), 209 deletions(-)
diff --git a/datafusion/core/src/physical_plan/planner.rs
b/datafusion/core/src/physical_plan/planner.rs
index 4a33b299b..5ccf9f70f 100644
--- a/datafusion/core/src/physical_plan/planner.rs
+++ b/datafusion/core/src/physical_plan/planner.rs
@@ -59,7 +59,7 @@ use arrow::compute::SortOptions;
use arrow::datatypes::{Schema, SchemaRef};
use async_trait::async_trait;
use datafusion_common::{DFSchema, ScalarValue};
-use datafusion_expr::expr::GroupingSet;
+use datafusion_expr::expr::{GroupingSet, Like};
use datafusion_expr::expr_rewriter::unnormalize_cols;
use datafusion_expr::utils::{expand_wildcard, expr_to_columns};
use datafusion_expr::WindowFrameUnits;
@@ -273,12 +273,12 @@ fn create_physical_name(e: &Expr, is_first_expr: bool) ->
Result<String> {
Ok(format!("{} BETWEEN {} AND {}", expr, low, high))
}
}
- Expr::Like {
+ Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
let expr = create_physical_name(expr, false)?;
let pattern = create_physical_name(pattern, false)?;
let escape = if let Some(char) = escape_char {
@@ -292,12 +292,12 @@ fn create_physical_name(e: &Expr, is_first_expr: bool) ->
Result<String> {
Ok(format!("{} LIKE {}{}", expr, pattern, escape))
}
}
- Expr::ILike {
+ Expr::ILike(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
let expr = create_physical_name(expr, false)?;
let pattern = create_physical_name(pattern, false)?;
let escape = if let Some(char) = escape_char {
@@ -311,12 +311,12 @@ fn create_physical_name(e: &Expr, is_first_expr: bool) ->
Result<String> {
Ok(format!("{} ILIKE {}{}", expr, pattern, escape))
}
}
- Expr::SimilarTo {
+ Expr::SimilarTo(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
let expr = create_physical_name(expr, false)?;
let pattern = create_physical_name(pattern, false)?;
let escape = if let Some(char) = escape_char {
diff --git a/datafusion/expr/src/expr.rs b/datafusion/expr/src/expr.rs
index 6f683dc7f..8b8938099 100644
--- a/datafusion/expr/src/expr.rs
+++ b/datafusion/expr/src/expr.rs
@@ -101,26 +101,11 @@ pub enum Expr {
right: Box<Expr>,
},
/// LIKE expression
- Like {
- negated: bool,
- expr: Box<Expr>,
- pattern: Box<Expr>,
- escape_char: Option<char>,
- },
+ Like(Like),
/// Case-insensitive LIKE expression
- ILike {
- negated: bool,
- expr: Box<Expr>,
- pattern: Box<Expr>,
- escape_char: Option<char>,
- },
+ ILike(Like),
/// LIKE expression that uses regular expressions
- SimilarTo {
- negated: bool,
- expr: Box<Expr>,
- pattern: Box<Expr>,
- escape_char: Option<char>,
- },
+ SimilarTo(Like),
/// Negation of an expression. The expression's type must be a boolean to
make sense.
Not(Box<Expr>),
/// Whether an expression is not Null. This expression is never null.
@@ -311,6 +296,32 @@ impl Case {
}
}
+/// LIKE expression
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub struct Like {
+ pub negated: bool,
+ pub expr: Box<Expr>,
+ pub pattern: Box<Expr>,
+ pub escape_char: Option<char>,
+}
+
+impl Like {
+ /// Create a new Like expression
+ pub fn new(
+ negated: bool,
+ expr: Box<Expr>,
+ pattern: Box<Expr>,
+ escape_char: Option<char>,
+ ) -> Self {
+ Self {
+ negated,
+ expr,
+ pattern,
+ escape_char,
+ }
+ }
+}
+
/// Grouping sets
/// See
https://www.postgresql.org/docs/current/queries-table-expressions.html#QUERIES-GROUPING-SETS
/// for Postgres definition.
@@ -580,39 +591,24 @@ impl Not for Expr {
fn not(self) -> Self::Output {
match self {
- Expr::Like {
+ Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
- } => Expr::Like {
- negated: !negated,
- expr,
- pattern,
- escape_char,
- },
- Expr::ILike {
+ }) => Expr::Like(Like::new(!negated, expr, pattern, escape_char)),
+ Expr::ILike(Like {
negated,
expr,
pattern,
escape_char,
- } => Expr::ILike {
- negated: !negated,
- expr,
- pattern,
- escape_char,
- },
- Expr::SimilarTo {
+ }) => Expr::ILike(Like::new(!negated, expr, pattern, escape_char)),
+ Expr::SimilarTo(Like {
negated,
expr,
pattern,
escape_char,
- } => Expr::SimilarTo {
- negated: !negated,
- expr,
- pattern,
- escape_char,
- },
+ }) => Expr::SimilarTo(Like::new(!negated, expr, pattern,
escape_char)),
_ => Expr::Not(Box::new(self)),
}
}
@@ -770,12 +766,12 @@ impl fmt::Debug for Expr {
write!(f, "{:?} BETWEEN {:?} AND {:?}", expr, low, high)
}
}
- Expr::Like {
+ Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
write!(f, "{:?}", expr)?;
if *negated {
write!(f, " NOT")?;
@@ -786,12 +782,12 @@ impl fmt::Debug for Expr {
write!(f, " LIKE {:?}", pattern)
}
}
- Expr::ILike {
+ Expr::ILike(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
write!(f, "{:?}", expr)?;
if *negated {
write!(f, " NOT")?;
@@ -802,12 +798,12 @@ impl fmt::Debug for Expr {
write!(f, " ILIKE {:?}", pattern)
}
}
- Expr::SimilarTo {
+ Expr::SimilarTo(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
write!(f, "{:?}", expr)?;
if *negated {
write!(f, " NOT")?;
@@ -925,12 +921,12 @@ fn create_name(e: &Expr) -> Result<String> {
let right = create_name(right)?;
Ok(format!("{} {} {}", left, op, right))
}
- Expr::Like {
+ Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
let s = format!(
"{} {} {} {}",
expr,
@@ -944,12 +940,12 @@ fn create_name(e: &Expr) -> Result<String> {
);
Ok(s)
}
- Expr::ILike {
+ Expr::ILike(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
let s = format!(
"{} {} {} {}",
expr,
@@ -963,12 +959,12 @@ fn create_name(e: &Expr) -> Result<String> {
);
Ok(s)
}
- Expr::SimilarTo {
+ Expr::SimilarTo(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
let s = format!(
"{} {} {} {}",
expr,
diff --git a/datafusion/expr/src/expr_rewriter.rs
b/datafusion/expr/src/expr_rewriter.rs
index 427fcf170..97d39ceb7 100644
--- a/datafusion/expr/src/expr_rewriter.rs
+++ b/datafusion/expr/src/expr_rewriter.rs
@@ -17,7 +17,7 @@
//! Expression rewriter
-use crate::expr::{Case, GroupingSet};
+use crate::expr::{Case, GroupingSet, Like};
use crate::logical_plan::{Aggregate, Projection};
use crate::utils::{from_plan, grouping_set_to_exprlist};
use crate::{Expr, ExprSchemable, LogicalPlan};
@@ -128,39 +128,39 @@ impl ExprRewritable for Expr {
op,
right: rewrite_boxed(right, rewriter)?,
},
- Expr::Like {
+ Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
- } => Expr::Like {
+ }) => Expr::Like(Like::new(
negated,
- expr: rewrite_boxed(expr, rewriter)?,
- pattern: rewrite_boxed(pattern, rewriter)?,
+ rewrite_boxed(expr, rewriter)?,
+ rewrite_boxed(pattern, rewriter)?,
escape_char,
- },
- Expr::ILike {
+ )),
+ Expr::ILike(Like {
negated,
expr,
pattern,
escape_char,
- } => Expr::ILike {
+ }) => Expr::ILike(Like::new(
negated,
- expr: rewrite_boxed(expr, rewriter)?,
- pattern: rewrite_boxed(pattern, rewriter)?,
+ rewrite_boxed(expr, rewriter)?,
+ rewrite_boxed(pattern, rewriter)?,
escape_char,
- },
- Expr::SimilarTo {
+ )),
+ Expr::SimilarTo(Like {
negated,
expr,
pattern,
escape_char,
- } => Expr::SimilarTo {
+ }) => Expr::SimilarTo(Like::new(
negated,
- expr: rewrite_boxed(expr, rewriter)?,
- pattern: rewrite_boxed(pattern, rewriter)?,
+ rewrite_boxed(expr, rewriter)?,
+ rewrite_boxed(pattern, rewriter)?,
escape_char,
- },
+ )),
Expr::Not(expr) => Expr::Not(rewrite_boxed(expr, rewriter)?),
Expr::IsNotNull(expr) => Expr::IsNotNull(rewrite_boxed(expr,
rewriter)?),
Expr::IsNull(expr) => Expr::IsNull(rewrite_boxed(expr, rewriter)?),
diff --git a/datafusion/expr/src/expr_schema.rs
b/datafusion/expr/src/expr_schema.rs
index cfcbcc940..103f8edcc 100644
--- a/datafusion/expr/src/expr_schema.rs
+++ b/datafusion/expr/src/expr_schema.rs
@@ -15,7 +15,7 @@
// specific language governing permissions and limitations
// under the License.
-use super::Expr;
+use super::{Expr, Like};
use crate::field_util::get_indexed_field;
use crate::type_coercion::binary::binary_operator_data_type;
use crate::{aggregate_function, function, window_function};
@@ -207,9 +207,9 @@ impl ExprSchemable for Expr {
ref right,
..
} => Ok(left.nullable(input_schema)? ||
right.nullable(input_schema)?),
- Expr::Like { expr, .. } => expr.nullable(input_schema),
- Expr::ILike { expr, .. } => expr.nullable(input_schema),
- Expr::SimilarTo { expr, .. } => expr.nullable(input_schema),
+ Expr::Like(Like { expr, .. }) => expr.nullable(input_schema),
+ Expr::ILike(Like { expr, .. }) => expr.nullable(input_schema),
+ Expr::SimilarTo(Like { expr, .. }) => expr.nullable(input_schema),
Expr::Wildcard => Err(DataFusionError::Internal(
"Wildcard expressions are not valid in a logical query
plan".to_owned(),
)),
diff --git a/datafusion/expr/src/expr_visitor.rs
b/datafusion/expr/src/expr_visitor.rs
index f362a759e..a7d19d255 100644
--- a/datafusion/expr/src/expr_visitor.rs
+++ b/datafusion/expr/src/expr_visitor.rs
@@ -17,7 +17,7 @@
//! Expression visitor
-use crate::{expr::GroupingSet, Expr};
+use crate::{expr::GroupingSet, Expr, Like};
use datafusion_common::Result;
/// Controls how the visitor recursion should proceed.
@@ -134,15 +134,15 @@ impl ExprVisitable for Expr {
let visitor = left.accept(visitor)?;
right.accept(visitor)
}
- Expr::Like { expr, pattern, .. } => {
+ Expr::Like(Like { expr, pattern, .. }) => {
let visitor = expr.accept(visitor)?;
pattern.accept(visitor)
}
- Expr::ILike { expr, pattern, .. } => {
+ Expr::ILike(Like { expr, pattern, .. }) => {
let visitor = expr.accept(visitor)?;
pattern.accept(visitor)
}
- Expr::SimilarTo { expr, pattern, .. } => {
+ Expr::SimilarTo(Like { expr, pattern, .. }) => {
let visitor = expr.accept(visitor)?;
pattern.accept(visitor)
}
diff --git a/datafusion/expr/src/lib.rs b/datafusion/expr/src/lib.rs
index e1bae3314..72a9cb747 100644
--- a/datafusion/expr/src/lib.rs
+++ b/datafusion/expr/src/lib.rs
@@ -56,7 +56,7 @@ pub use accumulator::{Accumulator, AggregateState};
pub use aggregate_function::AggregateFunction;
pub use built_in_function::BuiltinScalarFunction;
pub use columnar_value::{ColumnarValue, NullColumnarValue};
-pub use expr::{Case, Expr, GroupingSet};
+pub use expr::{Case, Expr, GroupingSet, Like};
pub use expr_fn::*;
pub use expr_schema::ExprSchemable;
pub use function::{
diff --git a/datafusion/optimizer/src/type_coercion.rs
b/datafusion/optimizer/src/type_coercion.rs
index ad9314406..f79b34246 100644
--- a/datafusion/optimizer/src/type_coercion.rs
+++ b/datafusion/optimizer/src/type_coercion.rs
@@ -21,7 +21,7 @@ use crate::utils::rewrite_preserving_name;
use crate::{OptimizerConfig, OptimizerRule};
use arrow::datatypes::DataType;
use datafusion_common::{DFSchema, DFSchemaRef, DataFusionError, Result};
-use datafusion_expr::expr::Case;
+use datafusion_expr::expr::{Case, Like};
use datafusion_expr::expr_rewriter::{ExprRewriter, RewriteRecursion};
use datafusion_expr::logical_plan::Subquery;
use datafusion_expr::type_coercion::binary::{coerce_types,
comparison_coercion};
@@ -168,44 +168,34 @@ impl ExprRewriter for TypeCoercionRewriter {
is_not_false(get_casted_expr_for_bool_op(&expr,
&self.schema)?);
Ok(expr)
}
- Expr::Like {
+ Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
let left_type = expr.get_type(&self.schema)?;
let right_type = pattern.get_type(&self.schema)?;
let coerced_type =
coerce_types(&left_type, &Operator::Like, &right_type)?;
let expr = Box::new(expr.cast_to(&coerced_type,
&self.schema)?);
let pattern = Box::new(pattern.cast_to(&coerced_type,
&self.schema)?);
- let expr = Expr::Like {
- negated,
- expr,
- pattern,
- escape_char,
- };
+ let expr = Expr::Like(Like::new(negated, expr, pattern,
escape_char));
Ok(expr)
}
- Expr::ILike {
+ Expr::ILike(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
let left_type = expr.get_type(&self.schema)?;
let right_type = pattern.get_type(&self.schema)?;
let coerced_type =
coerce_types(&left_type, &Operator::Like, &right_type)?;
let expr = Box::new(expr.cast_to(&coerced_type,
&self.schema)?);
let pattern = Box::new(pattern.cast_to(&coerced_type,
&self.schema)?);
- let expr = Expr::ILike {
- negated,
- expr,
- pattern,
- escape_char,
- };
+ let expr = Expr::ILike(Like::new(negated, expr, pattern,
escape_char));
Ok(expr)
}
Expr::IsUnknown(expr) => {
@@ -498,6 +488,7 @@ mod test {
use crate::{OptimizerConfig, OptimizerRule};
use arrow::datatypes::DataType;
use datafusion_common::{DFField, DFSchema, Result, ScalarValue};
+ use datafusion_expr::expr::Like;
use datafusion_expr::expr_rewriter::ExprRewritable;
use datafusion_expr::{
cast, col, concat, concat_ws, create_udaf, is_true,
@@ -885,12 +876,7 @@ mod test {
// like : utf8 like "abc"
let expr = Box::new(col("a"));
let pattern = Box::new(lit(ScalarValue::new_utf8("abc")));
- let like_expr = Expr::Like {
- negated: false,
- expr,
- pattern,
- escape_char: None,
- };
+ let like_expr = Expr::Like(Like::new(false, expr, pattern, None));
let empty = empty_with_type(DataType::Utf8);
let plan =
LogicalPlan::Projection(Projection::try_new(vec![like_expr],
empty, None)?);
@@ -904,12 +890,7 @@ mod test {
let expr = Box::new(col("a"));
let pattern = Box::new(lit(ScalarValue::Null));
- let like_expr = Expr::Like {
- negated: false,
- expr,
- pattern,
- escape_char: None,
- };
+ let like_expr = Expr::Like(Like::new(false, expr, pattern, None));
let empty = empty_with_type(DataType::Utf8);
let plan =
LogicalPlan::Projection(Projection::try_new(vec![like_expr],
empty, None)?);
@@ -924,12 +905,7 @@ mod test {
let expr = Box::new(col("a"));
let pattern = Box::new(lit(ScalarValue::new_utf8("abc")));
- let like_expr = Expr::Like {
- negated: false,
- expr,
- pattern,
- escape_char: None,
- };
+ let like_expr = Expr::Like(Like::new(false, expr, pattern, None));
let empty = empty_with_type(DataType::Int64);
let plan =
LogicalPlan::Projection(Projection::try_new(vec![like_expr],
empty, None)?);
diff --git a/datafusion/physical-expr/src/planner.rs
b/datafusion/physical-expr/src/planner.rs
index 993891884..6a454f841 100644
--- a/datafusion/physical-expr/src/planner.rs
+++ b/datafusion/physical-expr/src/planner.rs
@@ -27,7 +27,7 @@ use crate::{
};
use arrow::datatypes::{DataType, Schema};
use datafusion_common::{DFSchema, DataFusionError, Result, ScalarValue};
-use datafusion_expr::{binary_expr, Expr, Operator};
+use datafusion_expr::{binary_expr, Expr, Like, Operator};
use std::sync::Arc;
/// Create a physical expression from a logical expression ([Expr]).
@@ -201,12 +201,12 @@ pub fn create_physical_expr(
}
}
}
- Expr::Like {
+ Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
- } => {
+ }) => {
if escape_char.is_some() {
return Err(DataFusionError::Execution(
"LIKE does not support escape_char".to_string(),
diff --git a/datafusion/proto/src/from_proto.rs
b/datafusion/proto/src/from_proto.rs
index ffbf62658..b85ec2eda 100644
--- a/datafusion/proto/src/from_proto.rs
+++ b/datafusion/proto/src/from_proto.rs
@@ -43,7 +43,7 @@ use datafusion_expr::{
trim, trunc, upper, AggregateFunction, BuiltInWindowFunction,
BuiltinScalarFunction,
Case, Expr, GroupingSet,
GroupingSet::GroupingSets,
- Operator, WindowFrame, WindowFrameBound, WindowFrameUnits,
+ Like, Operator, WindowFrame, WindowFrameBound, WindowFrameUnits,
};
use std::sync::Arc;
@@ -926,24 +926,24 @@ pub fn parse_expr(
low: Box::new(parse_required_expr(&between.low, registry,
"expr")?),
high: Box::new(parse_required_expr(&between.high, registry,
"expr")?),
}),
- ExprType::Like(like) => Ok(Expr::Like {
- expr: Box::new(parse_required_expr(&like.expr, registry, "expr")?),
- negated: like.negated,
- pattern: Box::new(parse_required_expr(&like.pattern, registry,
"pattern")?),
- escape_char: parse_escape_char(&like.escape_char)?,
- }),
- ExprType::Ilike(like) => Ok(Expr::ILike {
- expr: Box::new(parse_required_expr(&like.expr, registry, "expr")?),
- negated: like.negated,
- pattern: Box::new(parse_required_expr(&like.pattern, registry,
"pattern")?),
- escape_char: parse_escape_char(&like.escape_char)?,
- }),
- ExprType::SimilarTo(like) => Ok(Expr::SimilarTo {
- expr: Box::new(parse_required_expr(&like.expr, registry, "expr")?),
- negated: like.negated,
- pattern: Box::new(parse_required_expr(&like.pattern, registry,
"pattern")?),
- escape_char: parse_escape_char(&like.escape_char)?,
- }),
+ ExprType::Like(like) => Ok(Expr::Like(Like::new(
+ like.negated,
+ Box::new(parse_required_expr(&like.expr, registry, "expr")?),
+ Box::new(parse_required_expr(&like.pattern, registry, "pattern")?),
+ parse_escape_char(&like.escape_char)?,
+ ))),
+ ExprType::Ilike(like) => Ok(Expr::ILike(Like::new(
+ like.negated,
+ Box::new(parse_required_expr(&like.expr, registry, "expr")?),
+ Box::new(parse_required_expr(&like.pattern, registry, "pattern")?),
+ parse_escape_char(&like.escape_char)?,
+ ))),
+ ExprType::SimilarTo(like) => Ok(Expr::SimilarTo(Like::new(
+ like.negated,
+ Box::new(parse_required_expr(&like.expr, registry, "expr")?),
+ Box::new(parse_required_expr(&like.pattern, registry, "pattern")?),
+ parse_escape_char(&like.escape_char)?,
+ ))),
ExprType::Case(case) => {
let when_then_expr = case
.when_then_expr
diff --git a/datafusion/proto/src/lib.rs b/datafusion/proto/src/lib.rs
index af5205cea..8d6344b79 100644
--- a/datafusion/proto/src/lib.rs
+++ b/datafusion/proto/src/lib.rs
@@ -63,7 +63,7 @@ mod roundtrip_tests {
use datafusion::prelude::{create_udf, CsvReadOptions, SessionContext};
use datafusion_common::{DFSchemaRef, DataFusionError, ScalarValue};
use datafusion_expr::create_udaf;
- use datafusion_expr::expr::{Case, GroupingSet};
+ use datafusion_expr::expr::{Case, GroupingSet, Like};
use datafusion_expr::logical_plan::{Extension, UserDefinedLogicalNode};
use datafusion_expr::{
col, lit, Accumulator, AggregateFunction, AggregateState,
@@ -940,12 +940,12 @@ mod roundtrip_tests {
#[test]
fn roundtrip_like() {
fn like(negated: bool, escape_char: Option<char>) {
- let test_expr = Expr::Like {
+ let test_expr = Expr::Like(Like::new(
negated,
- expr: Box::new(col("col")),
- pattern: Box::new(lit("[0-9]+")),
+ Box::new(col("col")),
+ Box::new(lit("[0-9]+")),
escape_char,
- };
+ ));
let ctx = SessionContext::new();
roundtrip_expr_test(test_expr, ctx);
}
@@ -958,12 +958,12 @@ mod roundtrip_tests {
#[test]
fn roundtrip_ilike() {
fn ilike(negated: bool, escape_char: Option<char>) {
- let test_expr = Expr::ILike {
+ let test_expr = Expr::ILike(Like::new(
negated,
- expr: Box::new(col("col")),
- pattern: Box::new(lit("[0-9]+")),
+ Box::new(col("col")),
+ Box::new(lit("[0-9]+")),
escape_char,
- };
+ ));
let ctx = SessionContext::new();
roundtrip_expr_test(test_expr, ctx);
}
@@ -976,12 +976,12 @@ mod roundtrip_tests {
#[test]
fn roundtrip_similar_to() {
fn similar_to(negated: bool, escape_char: Option<char>) {
- let test_expr = Expr::SimilarTo {
+ let test_expr = Expr::SimilarTo(Like::new(
negated,
- expr: Box::new(col("col")),
- pattern: Box::new(lit("[0-9]+")),
+ Box::new(col("col")),
+ Box::new(lit("[0-9]+")),
escape_char,
- };
+ ));
let ctx = SessionContext::new();
roundtrip_expr_test(test_expr, ctx);
}
diff --git a/datafusion/proto/src/to_proto.rs b/datafusion/proto/src/to_proto.rs
index 3c4f01075..06a72eae2 100644
--- a/datafusion/proto/src/to_proto.rs
+++ b/datafusion/proto/src/to_proto.rs
@@ -34,7 +34,7 @@ use arrow::datatypes::{
UnionMode,
};
use datafusion_common::{Column, DFField, DFSchemaRef, ScalarValue};
-use datafusion_expr::expr::GroupingSet;
+use datafusion_expr::expr::{GroupingSet, Like};
use datafusion_expr::{
logical_plan::PlanType, logical_plan::StringifiedPlan, AggregateFunction,
BuiltInWindowFunction, BuiltinScalarFunction, Expr, WindowFrame,
WindowFrameBound,
@@ -456,12 +456,7 @@ impl TryFrom<&Expr> for protobuf::LogicalExprNode {
expr_type: Some(ExprType::BinaryExpr(binary_expr)),
}
}
- Expr::Like {
- negated,
- expr,
- pattern,
- escape_char,
- } => {
+ Expr::Like(Like { negated, expr, pattern, escape_char} ) => {
let pb = Box::new(protobuf::LikeNode {
negated: *negated,
expr: Some(Box::new(expr.as_ref().try_into()?)),
@@ -474,12 +469,7 @@ impl TryFrom<&Expr> for protobuf::LogicalExprNode {
expr_type: Some(ExprType::Like(pb)),
}
}
- Expr::ILike {
- negated,
- expr,
- pattern,
- escape_char,
- } => {
+ Expr::ILike(Like { negated, expr, pattern, escape_char} ) => {
let pb = Box::new(protobuf::ILikeNode {
negated: *negated,
expr: Some(Box::new(expr.as_ref().try_into()?)),
@@ -492,12 +482,7 @@ impl TryFrom<&Expr> for protobuf::LogicalExprNode {
expr_type: Some(ExprType::Ilike(pb)),
}
}
- Expr::SimilarTo {
- negated,
- expr,
- pattern,
- escape_char,
- } => {
+ Expr::SimilarTo(Like { negated, expr, pattern, escape_char} ) => {
let pb = Box::new(protobuf::SimilarToNode {
negated: *negated,
expr: Some(Box::new(expr.as_ref().try_into()?)),
diff --git a/datafusion/row/src/writer.rs b/datafusion/row/src/writer.rs
index fcfaae976..e796be2a9 100644
--- a/datafusion/row/src/writer.rs
+++ b/datafusion/row/src/writer.rs
@@ -190,7 +190,7 @@ impl RowWriter {
fn set_bool(&mut self, idx: usize, value: bool) {
self.assert_index_valid(idx);
let offset = self.field_offsets()[idx];
- self.data[offset] = if value { 1 } else { 0 };
+ self.data[offset] = u8::from(value);
}
fn set_u8(&mut self, idx: usize, value: u8) {
diff --git a/datafusion/sql/src/planner.rs b/datafusion/sql/src/planner.rs
index 12fa1ae6c..6575445f0 100644
--- a/datafusion/sql/src/planner.rs
+++ b/datafusion/sql/src/planner.rs
@@ -51,7 +51,7 @@ use crate::utils::{make_decimal_type, normalize_ident,
resolve_columns};
use datafusion_common::{
field_not_found, Column, DFSchema, DFSchemaRef, DataFusionError, Result,
ScalarValue,
};
-use datafusion_expr::expr::{Case, GroupingSet};
+use datafusion_expr::expr::{Case, GroupingSet, Like};
use datafusion_expr::logical_plan::builder::project_with_alias;
use datafusion_expr::logical_plan::{Filter, Subquery};
use datafusion_expr::Expr::Alias;
@@ -1987,13 +1987,12 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
"Invalid pattern in LIKE expression".to_string(),
));
}
- Ok(Expr::Like {
+ Ok(Expr::Like(Like::new(
negated,
- expr: Box::new(self.sql_expr_to_logical_expr(*expr,
schema, ctes)?),
- pattern: Box::new(pattern),
+ Box::new(self.sql_expr_to_logical_expr(*expr, schema,
ctes)?),
+ Box::new(pattern),
escape_char
-
- })
+ )))
}
SQLExpr::ILike { negated, expr, pattern, escape_char } => {
@@ -2004,12 +2003,12 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
"Invalid pattern in ILIKE expression".to_string(),
));
}
- Ok(Expr::ILike {
+ Ok(Expr::ILike(Like::new(
negated,
- expr: Box::new(self.sql_expr_to_logical_expr(*expr,
schema, ctes)?),
- pattern: Box::new(pattern),
+ Box::new(self.sql_expr_to_logical_expr(*expr, schema,
ctes)?),
+ Box::new(pattern),
escape_char
- })
+ )))
}
SQLExpr::SimilarTo { negated, expr, pattern, escape_char } => {
@@ -2020,12 +2019,12 @@ impl<'a, S: ContextProvider> SqlToRel<'a, S> {
"Invalid pattern in SIMILAR TO expression".to_string(),
));
}
- Ok(Expr::SimilarTo {
+ Ok(Expr::SimilarTo(Like::new(
negated,
- expr: Box::new(self.sql_expr_to_logical_expr(*expr,
schema, ctes)?),
- pattern: Box::new(pattern),
+ Box::new(self.sql_expr_to_logical_expr(*expr, schema,
ctes)?),
+ Box::new(pattern),
escape_char
- })
+ )))
}
SQLExpr::BinaryOp {
diff --git a/datafusion/sql/src/utils.rs b/datafusion/sql/src/utils.rs
index 16f24deff..a786a21fc 100644
--- a/datafusion/sql/src/utils.rs
+++ b/datafusion/sql/src/utils.rs
@@ -21,7 +21,7 @@ use arrow::datatypes::{DataType, DECIMAL128_MAX_PRECISION,
DECIMAL_DEFAULT_SCALE
use sqlparser::ast::Ident;
use datafusion_common::{DataFusionError, Result, ScalarValue};
-use datafusion_expr::expr::{Case, GroupingSet};
+use datafusion_expr::expr::{Case, GroupingSet, Like};
use datafusion_expr::utils::{expr_as_column_expr, find_column_exprs};
use datafusion_expr::{Expr, LogicalPlan};
use std::collections::HashMap;
@@ -235,39 +235,39 @@ where
op: *op,
right: Box::new(clone_with_replacement(right,
replacement_fn)?),
}),
- Expr::Like {
+ Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
- } => Ok(Expr::Like {
- negated: *negated,
- expr: Box::new(clone_with_replacement(expr, replacement_fn)?),
- pattern: Box::new(clone_with_replacement(pattern,
replacement_fn)?),
- escape_char: *escape_char,
- }),
- Expr::ILike {
+ }) => Ok(Expr::Like(Like::new(
+ *negated,
+ Box::new(clone_with_replacement(expr, replacement_fn)?),
+ Box::new(clone_with_replacement(pattern, replacement_fn)?),
+ *escape_char,
+ ))),
+ Expr::ILike(Like {
negated,
expr,
pattern,
escape_char,
- } => Ok(Expr::ILike {
- negated: *negated,
- expr: Box::new(clone_with_replacement(expr, replacement_fn)?),
- pattern: Box::new(clone_with_replacement(pattern,
replacement_fn)?),
- escape_char: *escape_char,
- }),
- Expr::SimilarTo {
+ }) => Ok(Expr::ILike(Like::new(
+ *negated,
+ Box::new(clone_with_replacement(expr, replacement_fn)?),
+ Box::new(clone_with_replacement(pattern, replacement_fn)?),
+ *escape_char,
+ ))),
+ Expr::SimilarTo(Like {
negated,
expr,
pattern,
escape_char,
- } => Ok(Expr::SimilarTo {
- negated: *negated,
- expr: Box::new(clone_with_replacement(expr, replacement_fn)?),
- pattern: Box::new(clone_with_replacement(pattern,
replacement_fn)?),
- escape_char: *escape_char,
- }),
+ }) => Ok(Expr::SimilarTo(Like::new(
+ *negated,
+ Box::new(clone_with_replacement(expr, replacement_fn)?),
+ Box::new(clone_with_replacement(pattern, replacement_fn)?),
+ *escape_char,
+ ))),
Expr::Case(case) => Ok(Expr::Case(Case::new(
match &case.expr {
Some(case_expr) => {
