in src/ast/spans.rs [1401:1596]
fn span(&self) -> Span {
match self {
Expr::Identifier(ident) => ident.span,
Expr::CompoundIdentifier(vec) => union_spans(vec.iter().map(|i| i.span)),
Expr::CompoundFieldAccess { root, access_chain } => {
union_spans(iter::once(root.span()).chain(access_chain.iter().map(|i| i.span())))
}
Expr::IsFalse(expr) => expr.span(),
Expr::IsNotFalse(expr) => expr.span(),
Expr::IsTrue(expr) => expr.span(),
Expr::IsNotTrue(expr) => expr.span(),
Expr::IsNull(expr) => expr.span(),
Expr::IsNotNull(expr) => expr.span(),
Expr::IsUnknown(expr) => expr.span(),
Expr::IsNotUnknown(expr) => expr.span(),
Expr::IsDistinctFrom(lhs, rhs) => lhs.span().union(&rhs.span()),
Expr::IsNotDistinctFrom(lhs, rhs) => lhs.span().union(&rhs.span()),
Expr::InList {
expr,
list,
negated: _,
} => union_spans(
core::iter::once(expr.span()).chain(list.iter().map(|item| item.span())),
),
Expr::InSubquery {
expr,
subquery,
negated: _,
} => expr.span().union(&subquery.span()),
Expr::InUnnest {
expr,
array_expr,
negated: _,
} => expr.span().union(&array_expr.span()),
Expr::Between {
expr,
negated: _,
low,
high,
} => expr.span().union(&low.span()).union(&high.span()),
Expr::BinaryOp { left, op: _, right } => left.span().union(&right.span()),
Expr::Like {
negated: _,
expr,
pattern,
escape_char: _,
any: _,
} => expr.span().union(&pattern.span()),
Expr::ILike {
negated: _,
expr,
pattern,
escape_char: _,
any: _,
} => expr.span().union(&pattern.span()),
Expr::RLike { .. } => Span::empty(),
Expr::IsNormalized {
expr,
form: _,
negated: _,
} => expr.span(),
Expr::SimilarTo {
negated: _,
expr,
pattern,
escape_char: _,
} => expr.span().union(&pattern.span()),
Expr::Ceil { expr, field: _ } => expr.span(),
Expr::Floor { expr, field: _ } => expr.span(),
Expr::Position { expr, r#in } => expr.span().union(&r#in.span()),
Expr::Overlay {
expr,
overlay_what,
overlay_from,
overlay_for,
} => expr
.span()
.union(&overlay_what.span())
.union(&overlay_from.span())
.union_opt(&overlay_for.as_ref().map(|i| i.span())),
Expr::Collate { expr, collation } => expr
.span()
.union(&union_spans(collation.0.iter().map(|i| i.span()))),
Expr::Nested(expr) => expr.span(),
Expr::Value(value) => value.span(),
Expr::TypedString { value, .. } => value.span(),
Expr::Function(function) => function.span(),
Expr::GroupingSets(vec) => {
union_spans(vec.iter().flat_map(|i| i.iter().map(|k| k.span())))
}
Expr::Cube(vec) => union_spans(vec.iter().flat_map(|i| i.iter().map(|k| k.span()))),
Expr::Rollup(vec) => union_spans(vec.iter().flat_map(|i| i.iter().map(|k| k.span()))),
Expr::Tuple(vec) => union_spans(vec.iter().map(|i| i.span())),
Expr::Array(array) => array.span(),
Expr::MatchAgainst { .. } => Span::empty(),
Expr::JsonAccess { value, path } => value.span().union(&path.span()),
Expr::AnyOp {
left,
compare_op: _,
right,
is_some: _,
} => left.span().union(&right.span()),
Expr::AllOp {
left,
compare_op: _,
right,
} => left.span().union(&right.span()),
Expr::UnaryOp { op: _, expr } => expr.span(),
Expr::Convert {
expr,
data_type: _,
charset,
target_before_value: _,
styles,
is_try: _,
} => union_spans(
core::iter::once(expr.span())
.chain(charset.as_ref().map(|i| i.span()))
.chain(styles.iter().map(|i| i.span())),
),
Expr::Cast {
kind: _,
expr,
data_type: _,
format: _,
} => expr.span(),
Expr::AtTimeZone {
timestamp,
time_zone,
} => timestamp.span().union(&time_zone.span()),
Expr::Extract {
field: _,
syntax: _,
expr,
} => expr.span(),
Expr::Substring {
expr,
substring_from,
substring_for,
special: _,
shorthand: _,
} => union_spans(
core::iter::once(expr.span())
.chain(substring_from.as_ref().map(|i| i.span()))
.chain(substring_for.as_ref().map(|i| i.span())),
),
Expr::Trim {
expr,
trim_where: _,
trim_what,
trim_characters,
} => union_spans(
core::iter::once(expr.span())
.chain(trim_what.as_ref().map(|i| i.span()))
.chain(
trim_characters
.as_ref()
.map(|items| union_spans(items.iter().map(|i| i.span()))),
),
),
Expr::Prefixed { value, .. } => value.span(),
Expr::Case {
operand,
conditions,
else_result,
} => union_spans(
operand
.as_ref()
.map(|i| i.span())
.into_iter()
.chain(conditions.iter().flat_map(|case_when| {
[case_when.condition.span(), case_when.result.span()]
}))
.chain(else_result.as_ref().map(|i| i.span())),
),
Expr::Exists { subquery, .. } => subquery.span(),
Expr::Subquery(query) => query.span(),
Expr::Struct { .. } => Span::empty(),
Expr::Named { .. } => Span::empty(),
Expr::Dictionary(_) => Span::empty(),
Expr::Map(_) => Span::empty(),
Expr::Interval(interval) => interval.value.span(),
Expr::Wildcard(token) => token.0.span,
Expr::QualifiedWildcard(object_name, token) => union_spans(
object_name
.0
.iter()
.map(|i| i.span())
.chain(iter::once(token.0.span)),
),
Expr::OuterJoin(expr) => expr.span(),
Expr::Prior(expr) => expr.span(),
Expr::Lambda(_) => Span::empty(),
}
}