in datafusion/expr/src/tree_node/expr.rs [142:355]
fn map_children<F>(self, transform: F) -> Result<Self>
where
F: FnMut(Self) -> Result<Self>,
{
let mut transform = transform;
Ok(match self {
Expr::Alias(Alias { expr, name, .. }) => {
Expr::Alias(Alias::new(transform(*expr)?, name))
}
Expr::Column(_) => self,
Expr::OuterReferenceColumn(_, _) => self,
Expr::Exists { .. } => self,
Expr::InSubquery(InSubquery {
expr,
subquery,
negated,
}) => Expr::InSubquery(InSubquery::new(
transform_boxed(expr, &mut transform)?,
subquery,
negated,
)),
Expr::ScalarSubquery(_) => self,
Expr::ScalarVariable(ty, names) => Expr::ScalarVariable(ty, names),
Expr::Literal(value) => Expr::Literal(value),
Expr::BinaryExpr(BinaryExpr { left, op, right }) => {
Expr::BinaryExpr(BinaryExpr::new(
transform_boxed(left, &mut transform)?,
op,
transform_boxed(right, &mut transform)?,
))
}
Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
case_insensitive,
}) => Expr::Like(Like::new(
negated,
transform_boxed(expr, &mut transform)?,
transform_boxed(pattern, &mut transform)?,
escape_char,
case_insensitive,
)),
Expr::SimilarTo(Like {
negated,
expr,
pattern,
escape_char,
case_insensitive,
}) => Expr::SimilarTo(Like::new(
negated,
transform_boxed(expr, &mut transform)?,
transform_boxed(pattern, &mut transform)?,
escape_char,
case_insensitive,
)),
Expr::Not(expr) => Expr::Not(transform_boxed(expr, &mut transform)?),
Expr::IsNotNull(expr) => {
Expr::IsNotNull(transform_boxed(expr, &mut transform)?)
}
Expr::IsNull(expr) => Expr::IsNull(transform_boxed(expr, &mut transform)?),
Expr::IsTrue(expr) => Expr::IsTrue(transform_boxed(expr, &mut transform)?),
Expr::IsFalse(expr) => Expr::IsFalse(transform_boxed(expr, &mut transform)?),
Expr::IsUnknown(expr) => {
Expr::IsUnknown(transform_boxed(expr, &mut transform)?)
}
Expr::IsNotTrue(expr) => {
Expr::IsNotTrue(transform_boxed(expr, &mut transform)?)
}
Expr::IsNotFalse(expr) => {
Expr::IsNotFalse(transform_boxed(expr, &mut transform)?)
}
Expr::IsNotUnknown(expr) => {
Expr::IsNotUnknown(transform_boxed(expr, &mut transform)?)
}
Expr::Negative(expr) => {
Expr::Negative(transform_boxed(expr, &mut transform)?)
}
Expr::Between(Between {
expr,
negated,
low,
high,
}) => Expr::Between(Between::new(
transform_boxed(expr, &mut transform)?,
negated,
transform_boxed(low, &mut transform)?,
transform_boxed(high, &mut transform)?,
)),
Expr::Case(case) => {
let expr = transform_option_box(case.expr, &mut transform)?;
let when_then_expr = case
.when_then_expr
.into_iter()
.map(|(when, then)| {
Ok((
transform_boxed(when, &mut transform)?,
transform_boxed(then, &mut transform)?,
))
})
.collect::<Result<Vec<_>>>()?;
let else_expr = transform_option_box(case.else_expr, &mut transform)?;
Expr::Case(Case::new(expr, when_then_expr, else_expr))
}
Expr::Cast(Cast { expr, data_type }) => {
Expr::Cast(Cast::new(transform_boxed(expr, &mut transform)?, data_type))
}
Expr::TryCast(TryCast { expr, data_type }) => Expr::TryCast(TryCast::new(
transform_boxed(expr, &mut transform)?,
data_type,
)),
Expr::Sort(Sort {
expr,
asc,
nulls_first,
}) => Expr::Sort(Sort::new(
transform_boxed(expr, &mut transform)?,
asc,
nulls_first,
)),
Expr::ScalarFunction(ScalarFunction { args, fun }) => Expr::ScalarFunction(
ScalarFunction::new(fun, transform_vec(args, &mut transform)?),
),
Expr::ScalarUDF(ScalarUDF { args, fun }) => {
Expr::ScalarUDF(ScalarUDF::new(fun, transform_vec(args, &mut transform)?))
}
Expr::WindowFunction(WindowFunction {
args,
fun,
partition_by,
order_by,
window_frame,
}) => Expr::WindowFunction(WindowFunction::new(
fun,
transform_vec(args, &mut transform)?,
transform_vec(partition_by, &mut transform)?,
transform_vec(order_by, &mut transform)?,
window_frame,
)),
Expr::AggregateFunction(AggregateFunction {
args,
fun,
distinct,
filter,
order_by,
}) => Expr::AggregateFunction(AggregateFunction::new(
fun,
transform_vec(args, &mut transform)?,
distinct,
transform_option_box(filter, &mut transform)?,
transform_option_vec(order_by, &mut transform)?,
)),
Expr::GroupingSet(grouping_set) => match grouping_set {
GroupingSet::Rollup(exprs) => Expr::GroupingSet(GroupingSet::Rollup(
transform_vec(exprs, &mut transform)?,
)),
GroupingSet::Cube(exprs) => Expr::GroupingSet(GroupingSet::Cube(
transform_vec(exprs, &mut transform)?,
)),
GroupingSet::GroupingSets(lists_of_exprs) => {
Expr::GroupingSet(GroupingSet::GroupingSets(
lists_of_exprs
.iter()
.map(|exprs| transform_vec(exprs.clone(), &mut transform))
.collect::<Result<Vec<_>>>()?,
))
}
},
Expr::AggregateUDF(AggregateUDF {
args,
fun,
filter,
order_by,
}) => {
let order_by = if let Some(order_by) = order_by {
Some(transform_vec(order_by, &mut transform)?)
} else {
None
};
Expr::AggregateUDF(AggregateUDF::new(
fun,
transform_vec(args, &mut transform)?,
transform_option_box(filter, &mut transform)?,
transform_option_vec(order_by, &mut transform)?,
))
}
Expr::InList(InList {
expr,
list,
negated,
}) => Expr::InList(InList::new(
transform_boxed(expr, &mut transform)?,
transform_vec(list, &mut transform)?,
negated,
)),
Expr::Wildcard => Expr::Wildcard,
Expr::QualifiedWildcard { qualifier } => {
Expr::QualifiedWildcard { qualifier }
}
Expr::GetIndexedField(GetIndexedField { expr, field }) => {
Expr::GetIndexedField(GetIndexedField::new(
transform_boxed(expr, &mut transform)?,
field,
))
}
Expr::Placeholder(Placeholder { id, data_type }) => {
Expr::Placeholder(Placeholder { id, data_type })
}
})
}