[feat](case when) join extract or expression from case when / if / nullif expression #58430
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Contributor
|
Thank you for your contribution to Apache Doris. Please clearly describe your PR:
|
Contributor
Author
|
run buildall |
yujun777
force-pushed
the
join-extract-case-when
branch
from
620375c to
ec4225c
Compare
Contributor
Author
|
run buildall |
yujun777
force-pushed
the
join-extract-case-when
branch
from
ec4225c to
cdcdf48
Compare
Contributor
Author
|
run buildall |
yujun777
force-pushed
the
join-extract-case-when
branch
from
cdcdf48 to
e0360b8
Compare
Contributor
Author
|
run buildall |
1 similar comment
Contributor
Author
|
run buildall |
TPC-H: Total hot run time: 34179 ms |
TPC-DS: Total hot run time: 184153 ms |
ClickBench: Total hot run time: 27.36 s |
Contributor
FE Regression Coverage ReportIncrement line coverage |
Contributor
Author
|
run buildall |
TPC-H: Total hot run time: 34437 ms |
TPC-DS: Total hot run time: 184194 ms |
ClickBench: Total hot run time: 27.46 s |
Contributor
FE UT Coverage ReportIncrement line coverage |
yujun777
force-pushed
the
join-extract-case-when
branch
from
61bc61e to
7bcf8ec
Compare
Contributor
Author
|
run buildall |
yujun777
force-pushed
the
join-extract-case-when
branch
from
9e80c6a to
d98053f
Compare
Contributor
Author
|
run buildall |
TPC-H: Total hot run time: 34397 ms |
TPC-DS: Total hot run time: 185628 ms |
ClickBench: Total hot run time: 27.42 s |
starocean999
previously approved these changes
Nov 28, 2025
github-actions
bot
added
the
approved
Contributor
|
PR approved by at least one committer and no changes requested. |
Contributor
|
PR approved by anyone and no changes requested. |
yujun777
force-pushed
the
join-extract-case-when
branch
from
4ee3dc5 to
88c442b
Compare
Contributor
Author
|
run buildall |
morrySnow
approved these changes
Dec 1, 2025
github-actions
bot
added
the
approved
Contributor
|
PR approved by at least one committer and no changes requested. |
TPC-H: Total hot run time: 34015 ms |
TPC-DS: Total hot run time: 181988 ms |
ClickBench: Total hot run time: 27.48 s |
Contributor
FE UT Coverage ReportIncrement line coverage |
Contributor
Author
|
run external |
starocean999
approved these changes
Dec 2, 2025
yujun777
added a commit
to yujun777/doris
that referenced
this pull request
Dec 2, 2025
…llif expression (apache#58430) Join extract OR expressions from case when expression. 1. extract conditions for one side, latter can push down the one side condition: ``` t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b) + t2.b + t2.c > 10) => t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b end) + t2.b + t2.c > 10) AND (not (t2.a + t2.b + t2.c > 10) or not (t2.b + t2.b + t2.c > 10)) ``` 2. extract condition for both sides, which use for OR EXPANSION rule: the OR EXPANSION condition is an OR expression and all its disjuncts are all hash condition. ``` t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b => t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b AND (t2.a = t1.a + t1.b or t2.b = t1.a + t1.b) ``` Notice We don't extract more than one case when like expressions. because it may generate expressions with combinatorial explosion. for example: ``` (((case c1 then p1 else p2 end) + (case when d1 then q1 else q2 end))) + a > 10 => (p1 + q1 + a > 10) or (p1 + q2 + a > 10) or (p2 + q1 + a > 10) or (p2 + q2 + a > 10) ``` so we only extract at most one case when like expression for each condition.
16 tasks
yujun777
added a commit
to yujun777/doris
that referenced
this pull request
Dec 2, 2025
…llif expression (apache#58430) Join extract OR expressions from case when expression. 1. extract conditions for one side, latter can push down the one side condition: ``` t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b) + t2.b + t2.c > 10) => t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b end) + t2.b + t2.c > 10) AND (not (t2.a + t2.b + t2.c > 10) or not (t2.b + t2.b + t2.c > 10)) ``` 2. extract condition for both sides, which use for OR EXPANSION rule: the OR EXPANSION condition is an OR expression and all its disjuncts are all hash condition. ``` t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b => t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b AND (t2.a = t1.a + t1.b or t2.b = t1.a + t1.b) ``` Notice We don't extract more than one case when like expressions. because it may generate expressions with combinatorial explosion. for example: ``` (((case c1 then p1 else p2 end) + (case when d1 then q1 else q2 end))) + a > 10 => (p1 + q1 + a > 10) or (p1 + q2 + a > 10) or (p2 + q1 + a > 10) or (p2 + q2 + a > 10) ``` so we only extract at most one case when like expression for each condition.
yujun777
added a commit
to yujun777/doris
that referenced
this pull request
Dec 8, 2025
…llif expression (apache#58430) Join extract OR expressions from case when expression. 1. extract conditions for one side, latter can push down the one side condition: ``` t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b) + t2.b + t2.c > 10) => t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b end) + t2.b + t2.c > 10) AND (not (t2.a + t2.b + t2.c > 10) or not (t2.b + t2.b + t2.c > 10)) ``` 2. extract condition for both sides, which use for OR EXPANSION rule: the OR EXPANSION condition is an OR expression and all its disjuncts are all hash condition. ``` t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b => t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b AND (t2.a = t1.a + t1.b or t2.b = t1.a + t1.b) ``` Notice We don't extract more than one case when like expressions. because it may generate expressions with combinatorial explosion. for example: ``` (((case c1 then p1 else p2 end) + (case when d1 then q1 else q2 end))) + a > 10 => (p1 + q1 + a > 10) or (p1 + q2 + a > 10) or (p2 + q1 + a > 10) or (p2 + q2 + a > 10) ``` so we only extract at most one case when like expression for each condition.
nagisa-kunhah
pushed a commit
to nagisa-kunhah/doris
that referenced
this pull request
Dec 14, 2025
…llif expression (apache#58430) Join extract OR expressions from case when expression. 1. extract conditions for one side, latter can push down the one side condition: ``` t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b) + t2.b + t2.c > 10) => t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b end) + t2.b + t2.c > 10) AND (not (t2.a + t2.b + t2.c > 10) or not (t2.b + t2.b + t2.c > 10)) ``` 2. extract condition for both sides, which use for OR EXPANSION rule: the OR EXPANSION condition is an OR expression and all its disjuncts are all hash condition. ``` t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b => t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b AND (t2.a = t1.a + t1.b or t2.b = t1.a + t1.b) ``` Notice We don't extract more than one case when like expressions. because it may generate expressions with combinatorial explosion. for example: ``` (((case c1 then p1 else p2 end) + (case when d1 then q1 else q2 end))) + a > 10 => (p1 + q1 + a > 10) or (p1 + q2 + a > 10) or (p2 + q1 + a > 10) or (p2 + q2 + a > 10) ``` so we only extract at most one case when like expression for each condition.
yujun777
added a commit
to yujun777/doris
that referenced
this pull request
Jan 9, 2026
…llif expression (apache#58430) Join extract OR expressions from case when expression. 1. extract conditions for one side, latter can push down the one side condition: ``` t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b) + t2.b + t2.c > 10) => t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b end) + t2.b + t2.c > 10) AND (not (t2.a + t2.b + t2.c > 10) or not (t2.b + t2.b + t2.c > 10)) ``` 2. extract condition for both sides, which use for OR EXPANSION rule: the OR EXPANSION condition is an OR expression and all its disjuncts are all hash condition. ``` t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b => t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b AND (t2.a = t1.a + t1.b or t2.b = t1.a + t1.b) ``` Notice We don't extract more than one case when like expressions. because it may generate expressions with combinatorial explosion. for example: ``` (((case c1 then p1 else p2 end) + (case when d1 then q1 else q2 end))) + a > 10 => (p1 + q1 + a > 10) or (p1 + q2 + a > 10) or (p2 + q1 + a > 10) or (p2 + q2 + a > 10) ``` so we only extract at most one case when like expression for each condition.
yujun777
added a commit
to yujun777/doris
that referenced
this pull request
Jan 9, 2026
…llif expression (apache#58430) Join extract OR expressions from case when expression. 1. extract conditions for one side, latter can push down the one side condition: ``` t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b) + t2.b + t2.c > 10) => t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b end) + t2.b + t2.c > 10) AND (not (t2.a + t2.b + t2.c > 10) or not (t2.b + t2.b + t2.c > 10)) ``` 2. extract condition for both sides, which use for OR EXPANSION rule: the OR EXPANSION condition is an OR expression and all its disjuncts are all hash condition. ``` t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b => t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b AND (t2.a = t1.a + t1.b or t2.b = t1.a + t1.b) ``` Notice We don't extract more than one case when like expressions. because it may generate expressions with combinatorial explosion. for example: ``` (((case c1 then p1 else p2 end) + (case when d1 then q1 else q2 end))) + a > 10 => (p1 + q1 + a > 10) or (p1 + q2 + a > 10) or (p2 + q1 + a > 10) or (p2 + q2 + a > 10) ``` so we only extract at most one case when like expression for each condition.
yujun777
added a commit
to yujun777/doris
that referenced
this pull request
Jan 12, 2026
…llif expression (apache#58430) Join extract OR expressions from case when expression. 1. extract conditions for one side, latter can push down the one side condition: ``` t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b) + t2.b + t2.c > 10) => t1 join t2 on not (case when t1.a = 1 then t2.a else t2.b end) + t2.b + t2.c > 10) AND (not (t2.a + t2.b + t2.c > 10) or not (t2.b + t2.b + t2.c > 10)) ``` 2. extract condition for both sides, which use for OR EXPANSION rule: the OR EXPANSION condition is an OR expression and all its disjuncts are all hash condition. ``` t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b => t1 join t2 on (case when t1.a = 1 then t2.a else t2.b end) = t1.a + t1.b AND (t2.a = t1.a + t1.b or t2.b = t1.a + t1.b) ``` Notice We don't extract more than one case when like expressions. because it may generate expressions with combinatorial explosion. for example: ``` (((case c1 then p1 else p2 end) + (case when d1 then q1 else q2 end))) + a > 10 => (p1 + q1 + a > 10) or (p1 + q2 + a > 10) or (p2 + q1 + a > 10) or (p2 + q2 + a > 10) ``` so we only extract at most one case when like expression for each condition.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
6 participants
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
What problem does this PR solve?
Join extract OR expressions from case when expression.
extract condition for both sides, which use for OR EXPANSION rule:
the OR EXPANSION condition is an OR expression and all its disjuncts are all hash condition.
Notice We don't extract more than one case when like expressions.
because it may generate expressions with combinatorial explosion.
for example:
so we only extract at most one case when like expression for each condition.
Release note
None
Check List (For Author)
Test
Behavior changed:
Does this need documentation?
Check List (For Reviewer who merge this PR)