in datafusion/expr/src/expr.rs [2444:2690]
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
match self.0 {
// The same as Display
// TODO: remove the next line after `Expr::Wildcard` is removed
#[expect(deprecated)]
Expr::Column(_)
| Expr::Literal(_)
| Expr::ScalarVariable(..)
| Expr::OuterReferenceColumn(..)
| Expr::Placeholder(_)
| Expr::Wildcard { .. } => write!(f, "{}", self.0),
Expr::AggregateFunction(AggregateFunction { func, params }) => {
match func.schema_name(params) {
Ok(name) => {
write!(f, "{name}")
}
Err(e) => {
write!(f, "got error from schema_name {}", e)
}
}
}
// Expr is not shown since it is aliased
Expr::Alias(Alias {
name,
relation: Some(relation),
..
}) => write!(f, "{relation}.{name}"),
Expr::Alias(Alias { name, .. }) => write!(f, "{name}"),
Expr::Between(Between {
expr,
negated,
low,
high,
}) => {
if *negated {
write!(
f,
"{} NOT BETWEEN {} AND {}",
SchemaDisplay(expr),
SchemaDisplay(low),
SchemaDisplay(high),
)
} else {
write!(
f,
"{} BETWEEN {} AND {}",
SchemaDisplay(expr),
SchemaDisplay(low),
SchemaDisplay(high),
)
}
}
Expr::BinaryExpr(BinaryExpr { left, op, right }) => {
write!(f, "{} {op} {}", SchemaDisplay(left), SchemaDisplay(right),)
}
Expr::Case(Case {
expr,
when_then_expr,
else_expr,
}) => {
write!(f, "CASE ")?;
if let Some(e) = expr {
write!(f, "{} ", SchemaDisplay(e))?;
}
for (when, then) in when_then_expr {
write!(
f,
"WHEN {} THEN {} ",
SchemaDisplay(when),
SchemaDisplay(then),
)?;
}
if let Some(e) = else_expr {
write!(f, "ELSE {} ", SchemaDisplay(e))?;
}
write!(f, "END")
}
// Cast expr is not shown to be consistent with Postgres and Spark <https://github.com/apache/datafusion/pull/3222>
Expr::Cast(Cast { expr, .. }) | Expr::TryCast(TryCast { expr, .. }) => {
write!(f, "{}", SchemaDisplay(expr))
}
Expr::InList(InList {
expr,
list,
negated,
}) => {
let inlist_name = schema_name_from_exprs(list)?;
if *negated {
write!(f, "{} NOT IN {}", SchemaDisplay(expr), inlist_name)
} else {
write!(f, "{} IN {}", SchemaDisplay(expr), inlist_name)
}
}
Expr::Exists(Exists { negated: true, .. }) => write!(f, "NOT EXISTS"),
Expr::Exists(Exists { negated: false, .. }) => write!(f, "EXISTS"),
Expr::GroupingSet(GroupingSet::Cube(exprs)) => {
write!(f, "ROLLUP ({})", schema_name_from_exprs(exprs)?)
}
Expr::GroupingSet(GroupingSet::GroupingSets(lists_of_exprs)) => {
write!(f, "GROUPING SETS (")?;
for exprs in lists_of_exprs.iter() {
write!(f, "({})", schema_name_from_exprs(exprs)?)?;
}
write!(f, ")")
}
Expr::GroupingSet(GroupingSet::Rollup(exprs)) => {
write!(f, "ROLLUP ({})", schema_name_from_exprs(exprs)?)
}
Expr::IsNull(expr) => write!(f, "{} IS NULL", SchemaDisplay(expr)),
Expr::IsNotNull(expr) => {
write!(f, "{} IS NOT NULL", SchemaDisplay(expr))
}
Expr::IsUnknown(expr) => {
write!(f, "{} IS UNKNOWN", SchemaDisplay(expr))
}
Expr::IsNotUnknown(expr) => {
write!(f, "{} IS NOT UNKNOWN", SchemaDisplay(expr))
}
Expr::InSubquery(InSubquery { negated: true, .. }) => {
write!(f, "NOT IN")
}
Expr::InSubquery(InSubquery { negated: false, .. }) => write!(f, "IN"),
Expr::IsTrue(expr) => write!(f, "{} IS TRUE", SchemaDisplay(expr)),
Expr::IsFalse(expr) => write!(f, "{} IS FALSE", SchemaDisplay(expr)),
Expr::IsNotTrue(expr) => {
write!(f, "{} IS NOT TRUE", SchemaDisplay(expr))
}
Expr::IsNotFalse(expr) => {
write!(f, "{} IS NOT FALSE", SchemaDisplay(expr))
}
Expr::Like(Like {
negated,
expr,
pattern,
escape_char,
case_insensitive,
}) => {
write!(
f,
"{} {}{} {}",
SchemaDisplay(expr),
if *negated { "NOT " } else { "" },
if *case_insensitive { "ILIKE" } else { "LIKE" },
SchemaDisplay(pattern),
)?;
if let Some(char) = escape_char {
write!(f, " CHAR '{char}'")?;
}
Ok(())
}
Expr::Negative(expr) => write!(f, "(- {})", SchemaDisplay(expr)),
Expr::Not(expr) => write!(f, "NOT {}", SchemaDisplay(expr)),
Expr::Unnest(Unnest { expr }) => {
write!(f, "UNNEST({})", SchemaDisplay(expr))
}
Expr::ScalarFunction(ScalarFunction { func, args }) => {
match func.schema_name(args) {
Ok(name) => {
write!(f, "{name}")
}
Err(e) => {
write!(f, "got error from schema_name {}", e)
}
}
}
Expr::ScalarSubquery(Subquery { subquery, .. }) => {
write!(f, "{}", subquery.schema().field(0).name())
}
Expr::SimilarTo(Like {
negated,
expr,
pattern,
escape_char,
..
}) => {
write!(
f,
"{} {} {}",
SchemaDisplay(expr),
if *negated {
"NOT SIMILAR TO"
} else {
"SIMILAR TO"
},
SchemaDisplay(pattern),
)?;
if let Some(char) = escape_char {
write!(f, " CHAR '{char}'")?;
}
Ok(())
}
Expr::WindowFunction(WindowFunction { fun, params }) => match fun {
WindowFunctionDefinition::AggregateUDF(fun) => {
match fun.window_function_schema_name(params) {
Ok(name) => {
write!(f, "{name}")
}
Err(e) => {
write!(f, "got error from window_function_schema_name {}", e)
}
}
}
_ => {
let WindowFunctionParams {
args,
partition_by,
order_by,
window_frame,
null_treatment,
} = params;
write!(
f,
"{}({})",
fun,
schema_name_from_exprs_comma_separated_without_space(args)?
)?;
if let Some(null_treatment) = null_treatment {
write!(f, " {}", null_treatment)?;
}
if !partition_by.is_empty() {
write!(
f,
" PARTITION BY [{}]",
schema_name_from_exprs(partition_by)?
)?;
}
if !order_by.is_empty() {
write!(f, " ORDER BY [{}]", schema_name_from_sorts(order_by)?)?;
};
write!(f, " {window_frame}")
}
},
}
}