database/doris
2
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

[runtimeFilter](nereids) use runtime filter default size for debug purpose (#20065)

Browse Source 
use rf default size for debug
This commit is contained in:
minghong
2023-05-30 14:34:14 +08:00
committed by GitHub
parent a220b1c34a
commit e623f3fb9e
8 changed files with 295 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/AbstractPhysicalJoin.java
View File

@ -53,6 +53,7 @@ public abstract class AbstractPhysicalJoin<
protected final List<Expression> otherJoinConjuncts;
protected final JoinHint hint;
protected final Optional<MarkJoinSlotReference> markJoinSlotReference;
protected final List<RuntimeFilter> runtimeFilters = Lists.newArrayList();
// use for translate only
protected final List<Expression> filterConjuncts = Lists.newArrayList();
@ -197,4 +198,12 @@ public abstract class AbstractPhysicalJoin<
physicalJoin.put("Properties", properties);
return physicalJoin;
}
public void addRuntimeFilter(RuntimeFilter rf) {
runtimeFilters.add(rf);
}
public List<RuntimeFilter> getRuntimeFilters() {
return runtimeFilters;
}
}

4
fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/PhysicalHashJoin.java
View File

@ -145,6 +145,10 @@ public class PhysicalHashJoin<
args.add("hint");
args.add(hint);
}
if (!runtimeFilters.isEmpty()) {
args.add("runtimeFilters");
args.add(runtimeFilters.stream().map(rf -> rf.toString() + " ").collect(Collectors.toList()));
}
return Utils.toSqlString("PhysicalHashJoin[" + id.asInt() + "]" + getGroupIdAsString(),
args.toArray());
}

12
fe/fe-core/src/main/java/org/apache/doris/nereids/trees/plans/physical/RuntimeFilter.java
View File

@ -64,6 +64,7 @@ public class RuntimeFilter {
this.builderNode = builderNode;
this.bitmapFilterNotIn = bitmapFilterNotIn;
this.buildSideNdv = buildSideNdv <= 0 ? -1L : buildSideNdv;
builderNode.addRuntimeFilter(this);
}
public Expression getSrcExpr() {
@ -101,4 +102,15 @@ public class RuntimeFilter {
public long getBuildSideNdv() {
return buildSideNdv;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("RF").append(id.asInt())
.append("[").append(getSrcExpr()).append("->").append(targetSlot)
.append("(ndv/size = ").append(buildSideNdv).append("/")
.append(org.apache.doris.planner.RuntimeFilter.expectRuntimeFilterSize(buildSideNdv))
.append(")");
return sb.toString();
}
}

3
fe/fe-core/src/main/java/org/apache/doris/planner/PlanNode.java
View File

@ -1028,6 +1028,9 @@ public abstract class PlanNode extends TreeNode<PlanNode> implements PlanStats {
if (isBuildNode) {
filterStr.append(" <- ");
filterStr.append(filter.getSrcExpr().toSql());
filterStr.append("(").append(filter.getEstimateNdv()).append("/")
.append(filter.getExpectFilterSizeBytes()).append("/")
.append(filter.getFilterSizeBytes()).append(")");
} else {
filterStr.append(" -> ");
filterStr.append(filter.getTargetExpr(getId()).toSql());

26
fe/fe-core/src/main/java/org/apache/doris/planner/RuntimeFilter.java
View File

@ -33,6 +33,7 @@ import org.apache.doris.catalog.Type;
import org.apache.doris.common.FeConstants;
import org.apache.doris.common.IdGenerator;
import org.apache.doris.qe.ConnectContext;
import org.apache.doris.qe.SessionVariable;
import org.apache.doris.thrift.TRuntimeFilterDesc;
import org.apache.doris.thrift.TRuntimeFilterType;
@ -86,7 +87,8 @@ public final class RuntimeFilter {
private long ndvEstimate = -1;
// Size of the filter (in Bytes). Should be greater than zero for bloom filters.
private long filterSizeBytes = 0;
public long expectFilterSizeBytes = 0;
private long expectFilterSizeBytes = 0;
// If true, the filter is produced by a broadcast join and there is at least one
// destination scan node which is in the same fragment as the join; set in
// DistributedPlanner.createHashJoinFragment().
@ -546,19 +548,28 @@ public final class RuntimeFilter {
* Considering that the `IN` filter may be converted to the `Bloom FIlter` when crossing fragments,
* the bloom filter size is always calculated.
*/
private void calculateFilterSize(RuntimeFilterGenerator.FilterSizeLimits filterSizeLimits) {
public void calculateFilterSize(RuntimeFilterGenerator.FilterSizeLimits filterSizeLimits) {
if (ndvEstimate == -1) {
filterSizeBytes = filterSizeLimits.defaultVal;
return;
}
double fpp = FeConstants.default_bloom_filter_fpp;
int logFilterSize = getMinLogSpaceForBloomFilter(ndvEstimate, fpp);
filterSizeBytes = 1L << logFilterSize;
SessionVariable sessionVariable = ConnectContext.get().getSessionVariable();
if (sessionVariable.useRuntimeFilterDefaultSize) {
filterSizeBytes = filterSizeLimits.defaultVal;
return;
}
filterSizeBytes = expectRuntimeFilterSize(ndvEstimate);
expectFilterSizeBytes = filterSizeBytes;
filterSizeBytes = Math.max(filterSizeBytes, filterSizeLimits.minVal);
filterSizeBytes = Math.min(filterSizeBytes, filterSizeLimits.maxVal);
}
public static long expectRuntimeFilterSize(long ndv) {
double fpp = FeConstants.default_bloom_filter_fpp;
int logFilterSize = getMinLogSpaceForBloomFilter(ndv, fpp);
return 1L << logFilterSize;
}
/**
* Returns the log (base 2) of the minimum number of bytes we need for a Bloom
* filter with 'ndv' unique elements and a false positive probability of less
@ -620,4 +631,9 @@ public final class RuntimeFilter {
+ Joiner.on(", ").join(targets) + " "
+ "Selectivity: " + getSelectivity();
}
public long getExpectFilterSizeBytes() {
return expectFilterSizeBytes;
}
}

3
fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java
View File

@ -637,6 +637,9 @@ public class SessionVariable implements Serializable, Writable {
@VariableMgr.VarAttr(name = RUNTIME_FILTER_MAX_IN_NUM)
private int runtimeFilterMaxInNum = 102400;
@VariableMgr.VarAttr(name = USE_RF_DEFAULT)
public boolean useRuntimeFilterDefaultSize = false;
public int getBeNumberForTest() {
return beNumberForTest;
}

109
fe/fe-core/src/test/java/org/apache/doris/planner/QueryPlanTest.java
View File

@ -1408,98 +1408,131 @@ public class QueryPlanTest extends TestWithFeService {
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 1);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 2);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 3);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`, RF001[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`, RF001[bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 4);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[min_max] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[min_max] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 5);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`, RF001[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`, RF001[min_max] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[min_max] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 6);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[bloom] <- `t1`.`k1`, RF001[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[bloom] -> `t2`.`k1`, RF001[min_max] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[min_max] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 7);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`, RF001[bloom] <- `t1`.`k1`,"
+ " RF002[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`, RF001[bloom] -> `t2`.`k1`,"
+ " RF002[min_max] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[min_max] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 8);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in_or_bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 9);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`, RF001[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`, RF001[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[in_or_bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 10);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[bloom] <- `t1`.`k1`, RF001[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[bloom] -> `t2`.`k1`, RF001[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[in_or_bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 11);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`, RF001[bloom] <- `t1`.`k1`, RF002[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`, RF001[bloom] -> `t2`.`k1`, RF002[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[in_or_bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 12);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[min_max] <- `t1`.`k1`, RF001[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[min_max] -> `t2`.`k1`, RF001[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[min_max] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[in_or_bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 13);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`, RF001[min_max] <- `t1`.`k1`, RF002[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`, RF001[min_max] -> `t2`.`k1`, RF002[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[min_max] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[in_or_bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 14);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[bloom] <- `t1`.`k1`, RF001[min_max] <- `t1`.`k1`, RF002[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[bloom] -> `t2`.`k1`, RF001[min_max] -> `t2`.`k1`, RF002[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[min_max] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[in_or_bloom] -> `t2`.`k1`"));
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", 15);
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`, RF001[bloom] <- `t1`.`k1`, RF002[min_max] <- `t1`.`k1`, RF003[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`, RF001[bloom] -> `t2`.`k1`, RF002[min_max] -> `t2`.`k1`, RF003[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[min_max] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF003[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF001[bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF002[min_max] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF003[in_or_bloom] -> `t2`.`k1`"));
// support merge in filter, and forbidden implicit conversion to bloom filter
queryStr = "explain select * from jointest t2 join [shuffle] jointest t1 where t1.k1 = t2.k1";
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterMode", "GLOBAL");
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", TRuntimeFilterType.IN.getValue());
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in] <- `t1`.`k1`"));
Assert.assertFalse(explainString.contains("runtime filters: RF000[bloom] -> `t2`.`k1`"));
Assert.assertFalse(explainString.contains("runtime filters: RF000[bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in] <- `t1`.`k1`"));
Assert.assertFalse(explainString.contains("RF000[bloom] -> `t2`.`k1`"));
Assert.assertFalse(explainString.contains("RF000[bloom] <- `t1`.`k1`"));
queryStr = "explain select * from jointest t2 join [shuffle] jointest t1 where t1.k1 = t2.k1";
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterMode", "GLOBAL");
Deencapsulation.setField(connectContext.getSessionVariable(), "runtimeFilterType", TRuntimeFilterType.IN_OR_BLOOM.getValue());
explainString = getSQLPlanOrErrorMsg(queryStr);
Assert.assertTrue(explainString.contains("runtime filters: RF000[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("runtime filters: RF000[in_or_bloom] <- `t1`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in_or_bloom] -> `t2`.`k1`"));
Assert.assertTrue(explainString.contains("RF000[in_or_bloom] <- `t1`.`k1`"));
}
@Test

274
fe/fe-core/src/test/java/org/apache/doris/planner/RuntimeFilterGeneratorTest.java
View File

@ -155,16 +155,21 @@ public class RuntimeFilterGeneratorTest {
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 4);
Assert.assertEquals(hashJoinNode.getRuntimeFilters().size(), 4);
Assert.assertEquals(lhsScanNode.getRuntimeFilters().size(), 4);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF002[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF003[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF002[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF003[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
String rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains("RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains("RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF003[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains("RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains("RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF003[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
clearRuntimeFilterState();
new Expectations() {
@ -179,16 +184,23 @@ public class RuntimeFilterGeneratorTest {
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 4);
Assert.assertEquals(hashJoinNode.getRuntimeFilters().size(), 4);
Assert.assertEquals(lhsScanNode.getRuntimeFilters().size(), 4);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF002[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF003[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF002[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF003[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains("RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF003[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF003[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
clearRuntimeFilterState();
new Expectations() {
@ -248,7 +260,7 @@ public class RuntimeFilterGeneratorTest {
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`(-1/0/2097152)\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 1);
@ -266,7 +278,7 @@ public class RuntimeFilterGeneratorTest {
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
"RF000[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`(-1/0/2097152)\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 1);
@ -283,12 +295,16 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
String rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 2);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 2);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 2);
@ -304,7 +320,7 @@ public class RuntimeFilterGeneratorTest {
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
"RF000[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`(-1/0/2097152)\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 1);
@ -321,12 +337,16 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 2);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 2);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 2);
@ -341,12 +361,17 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 2);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 2);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 2);
@ -361,14 +386,20 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF002[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF002[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 3);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 3);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 3);
@ -384,7 +415,7 @@ public class RuntimeFilterGeneratorTest {
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
"RF000[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`(-1/0/2097152)\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 1);
@ -401,12 +432,17 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 2);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 2);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 2);
@ -421,12 +457,16 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 2);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 2);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 2);
@ -441,14 +481,20 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF002[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF002[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 3);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 3);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 3);
@ -463,12 +509,16 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 2);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 2);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 2);
@ -483,14 +533,20 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF002[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF002[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 3);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 3);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 3);
@ -506,14 +562,20 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF002[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF002[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 3);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 3);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 3);
@ -528,16 +590,24 @@ public class RuntimeFilterGeneratorTest {
}
};
RuntimeFilterGenerator.generateRuntimeFilters(analyzer, hashJoinNode);
Assert.assertEquals(hashJoinNode.getRuntimeFilterExplainString(true),
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF002[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"
+ ", RF003[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`\n");
Assert.assertEquals(lhsScanNode.getRuntimeFilterExplainString(false),
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF002[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"
+ ", RF003[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`\n");
rfString = hashJoinNode.getRuntimeFilterExplainString(true);
Assert.assertTrue(rfString.contains(
"RF000[in] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[min_max] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
Assert.assertTrue(rfString.contains(
"RF003[in_or_bloom] <- `default_cluster:test_db`.`test_rhs_tbl`.`test_rhs_col`"));
rfString = lhsScanNode.getRuntimeFilterExplainString(false);
Assert.assertTrue(rfString.contains(
"RF000[in] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF001[bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF002[min_max] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertTrue(rfString.contains(
"RF003[in_or_bloom] -> `default_cluster:test_db`.`test_lhs_tbl`.`test_lhs_col`"));
Assert.assertEquals(testPlanFragment.getTargetRuntimeFilterIds().size(), 4);
Assert.assertEquals(testPlanFragment.getBuilderRuntimeFilterIds().size(), 4);
Assert.assertEquals(analyzer.getAssignedRuntimeFilter().size(), 4);